2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* kernel/sched.c
|
|
|
|
*
|
|
|
|
* Kernel scheduler and related syscalls
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991-2002 Linus Torvalds
|
|
|
|
*
|
|
|
|
* 1996-12-23 Modified by Dave Grothe to fix bugs in semaphores and
|
|
|
|
* make semaphores SMP safe
|
|
|
|
* 1998-11-19 Implemented schedule_timeout() and related stuff
|
|
|
|
* by Andrea Arcangeli
|
|
|
|
* 2002-01-04 New ultra-scalable O(1) scheduler by Ingo Molnar:
|
|
|
|
* hybrid priority-list and round-robin design with
|
|
|
|
* an array-switch method of distributing timeslices
|
|
|
|
* and per-CPU runqueues. Cleanups and useful suggestions
|
|
|
|
* by Davide Libenzi, preemptible kernel bits by Robert Love.
|
|
|
|
* 2003-09-03 Interactivity tuning by Con Kolivas.
|
|
|
|
* 2004-04-02 Scheduler domains code by Nick Piggin
|
2007-07-09 23:52:01 +07:00
|
|
|
* 2007-04-15 Work begun on replacing all interactivity tuning with a
|
|
|
|
* fair scheduling design by Con Kolivas.
|
|
|
|
* 2007-05-05 Load balancing (smp-nice) and other improvements
|
|
|
|
* by Peter Williams
|
|
|
|
* 2007-05-06 Interactivity improvements to CFS by Mike Galbraith
|
|
|
|
* 2007-07-01 Group scheduling enhancements by Srivatsa Vaddagiri
|
2008-01-26 03:08:19 +07:00
|
|
|
* 2007-11-29 RT balancing improvements by Steven Rostedt, Gregory Haskins,
|
|
|
|
* Thomas Gleixner, Mike Kravetz
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/nmi.h>
|
|
|
|
#include <linux/init.h>
|
2007-07-09 23:52:00 +07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/smp_lock.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <linux/interrupt.h>
|
2006-01-12 03:17:46 +07:00
|
|
|
#include <linux/capability.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
2006-07-03 14:24:33 +07:00
|
|
|
#include <linux/debug_locks.h>
|
perf: Do the big rename: Performance Counters -> Performance Events
Bye-bye Performance Counters, welcome Performance Events!
In the past few months the perfcounters subsystem has grown out its
initial role of counting hardware events, and has become (and is
becoming) a much broader generic event enumeration, reporting, logging,
monitoring, analysis facility.
Naming its core object 'perf_counter' and naming the subsystem
'perfcounters' has become more and more of a misnomer. With pending
code like hw-breakpoints support the 'counter' name is less and
less appropriate.
All in one, we've decided to rename the subsystem to 'performance
events' and to propagate this rename through all fields, variables
and API names. (in an ABI compatible fashion)
The word 'event' is also a bit shorter than 'counter' - which makes
it slightly more convenient to write/handle as well.
Thanks goes to Stephane Eranian who first observed this misnomer and
suggested a rename.
User-space tooling and ABI compatibility is not affected - this patch
should be function-invariant. (Also, defconfigs were not touched to
keep the size down.)
This patch has been generated via the following script:
FILES=$(find * -type f | grep -vE 'oprofile|[^K]config')
sed -i \
-e 's/PERF_EVENT_/PERF_RECORD_/g' \
-e 's/PERF_COUNTER/PERF_EVENT/g' \
-e 's/perf_counter/perf_event/g' \
-e 's/nb_counters/nb_events/g' \
-e 's/swcounter/swevent/g' \
-e 's/tpcounter_event/tp_event/g' \
$FILES
for N in $(find . -name perf_counter.[ch]); do
M=$(echo $N | sed 's/perf_counter/perf_event/g')
mv $N $M
done
FILES=$(find . -name perf_event.*)
sed -i \
-e 's/COUNTER_MASK/REG_MASK/g' \
-e 's/COUNTER/EVENT/g' \
-e 's/\<event\>/event_id/g' \
-e 's/counter/event/g' \
-e 's/Counter/Event/g' \
$FILES
... to keep it as correct as possible. This script can also be
used by anyone who has pending perfcounters patches - it converts
a Linux kernel tree over to the new naming. We tried to time this
change to the point in time where the amount of pending patches
is the smallest: the end of the merge window.
Namespace clashes were fixed up in a preparatory patch - and some
stylistic fallout will be fixed up in a subsequent patch.
( NOTE: 'counters' are still the proper terminology when we deal
with hardware registers - and these sed scripts are a bit
over-eager in renaming them. I've undone some of that, but
in case there's something left where 'counter' would be
better than 'event' we can undo that on an individual basis
instead of touching an otherwise nicely automated patch. )
Suggested-by: Stephane Eranian <eranian@google.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Paul Mackerras <paulus@samba.org>
Reviewed-by: Arjan van de Ven <arjan@linux.intel.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: <linux-arch@vger.kernel.org>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-21 17:02:48 +07:00
|
|
|
#include <linux/perf_event.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/profile.h>
|
2006-12-07 11:34:23 +07:00
|
|
|
#include <linux/freezer.h>
|
[PATCH] scheduler cache-hot-autodetect
)
From: Ingo Molnar <mingo@elte.hu>
This is the latest version of the scheduler cache-hot-auto-tune patch.
The first problem was that detection time scaled with O(N^2), which is
unacceptable on larger SMP and NUMA systems. To solve this:
- I've added a 'domain distance' function, which is used to cache
measurement results. Each distance is only measured once. This means
that e.g. on NUMA distances of 0, 1 and 2 might be measured, on HT
distances 0 and 1, and on SMP distance 0 is measured. The code walks
the domain tree to determine the distance, so it automatically follows
whatever hierarchy an architecture sets up. This cuts down on the boot
time significantly and removes the O(N^2) limit. The only assumption
is that migration costs can be expressed as a function of domain
distance - this covers the overwhelming majority of existing systems,
and is a good guess even for more assymetric systems.
[ People hacking systems that have assymetries that break this
assumption (e.g. different CPU speeds) should experiment a bit with
the cpu_distance() function. Adding a ->migration_distance factor to
the domain structure would be one possible solution - but lets first
see the problem systems, if they exist at all. Lets not overdesign. ]
Another problem was that only a single cache-size was used for measuring
the cost of migration, and most architectures didnt set that variable
up. Furthermore, a single cache-size does not fit NUMA hierarchies with
L3 caches and does not fit HT setups, where different CPUs will often
have different 'effective cache sizes'. To solve this problem:
- Instead of relying on a single cache-size provided by the platform and
sticking to it, the code now auto-detects the 'effective migration
cost' between two measured CPUs, via iterating through a wide range of
cachesizes. The code searches for the maximum migration cost, which
occurs when the working set of the test-workload falls just below the
'effective cache size'. I.e. real-life optimized search is done for
the maximum migration cost, between two real CPUs.
This, amongst other things, has the positive effect hat if e.g. two
CPUs share a L2/L3 cache, a different (and accurate) migration cost
will be found than between two CPUs on the same system that dont share
any caches.
(The reliable measurement of migration costs is tricky - see the source
for details.)
Furthermore i've added various boot-time options to override/tune
migration behavior.
Firstly, there's a blanket override for autodetection:
migration_cost=1000,2000,3000
will override the depth 0/1/2 values with 1msec/2msec/3msec values.
Secondly, there's a global factor that can be used to increase (or
decrease) the autodetected values:
migration_factor=120
will increase the autodetected values by 20%. This option is useful to
tune things in a workload-dependent way - e.g. if a workload is
cache-insensitive then CPU utilization can be maximized by specifying
migration_factor=0.
I've tested the autodetection code quite extensively on x86, on 3
P3/Xeon/2MB, and the autodetected values look pretty good:
Dual Celeron (128K L2 cache):
---------------------
migration cost matrix (max_cache_size: 131072, cpu: 467 MHz):
---------------------
[00] [01]
[00]: - 1.7(1)
[01]: 1.7(1) -
---------------------
cacheflush times [2]: 0.0 (0) 1.7 (1784008)
---------------------
Here the slow memory subsystem dominates system performance, and even
though caches are small, the migration cost is 1.7 msecs.
Dual HT P4 (512K L2 cache):
---------------------
migration cost matrix (max_cache_size: 524288, cpu: 2379 MHz):
---------------------
[00] [01] [02] [03]
[00]: - 0.4(1) 0.0(0) 0.4(1)
[01]: 0.4(1) - 0.4(1) 0.0(0)
[02]: 0.0(0) 0.4(1) - 0.4(1)
[03]: 0.4(1) 0.0(0) 0.4(1) -
---------------------
cacheflush times [2]: 0.0 (33900) 0.4 (448514)
---------------------
Here it can be seen that there is no migration cost between two HT
siblings (CPU#0/2 and CPU#1/3 are separate physical CPUs). A fast memory
system makes inter-physical-CPU migration pretty cheap: 0.4 msecs.
8-way P3/Xeon [2MB L2 cache]:
---------------------
migration cost matrix (max_cache_size: 2097152, cpu: 700 MHz):
---------------------
[00] [01] [02] [03] [04] [05] [06] [07]
[00]: - 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[01]: 19.2(1) - 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[02]: 19.2(1) 19.2(1) - 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[03]: 19.2(1) 19.2(1) 19.2(1) - 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[04]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) - 19.2(1) 19.2(1) 19.2(1)
[05]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) - 19.2(1) 19.2(1)
[06]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) - 19.2(1)
[07]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) -
---------------------
cacheflush times [2]: 0.0 (0) 19.2 (19281756)
---------------------
This one has huge caches and a relatively slow memory subsystem - so the
migration cost is 19 msecs.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: Ken Chen <kenneth.w.chen@intel.com>
Cc: <wilder@us.ibm.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-12 16:05:30 +07:00
|
|
|
#include <linux/vmalloc.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/delay.h>
|
2007-10-19 13:40:14 +07:00
|
|
|
#include <linux/pid_namespace.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/cpuset.h>
|
|
|
|
#include <linux/percpu.h>
|
2008-10-06 16:23:43 +07:00
|
|
|
#include <linux/proc_fs.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/seq_file.h>
|
2010-05-06 23:49:21 +07:00
|
|
|
#include <linux/stop_machine.h>
|
2007-07-26 18:40:43 +07:00
|
|
|
#include <linux/sysctl.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/times.h>
|
2006-10-01 13:28:59 +07:00
|
|
|
#include <linux/tsacct_kern.h>
|
2006-03-26 16:38:20 +07:00
|
|
|
#include <linux/kprobes.h>
|
2006-07-14 14:24:37 +07:00
|
|
|
#include <linux/delayacct.h>
|
2007-07-09 23:52:00 +07:00
|
|
|
#include <linux/unistd.h>
|
2007-09-21 14:19:54 +07:00
|
|
|
#include <linux/pagemap.h>
|
2008-01-26 03:08:29 +07:00
|
|
|
#include <linux/hrtimer.h>
|
2008-03-18 06:19:05 +07:00
|
|
|
#include <linux/tick.h>
|
2008-04-20 00:45:00 +07:00
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/ctype.h>
|
2008-05-13 02:20:42 +07:00
|
|
|
#include <linux/ftrace.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-05-08 14:32:57 +07:00
|
|
|
#include <asm/tlb.h>
|
2007-10-24 23:23:50 +07:00
|
|
|
#include <asm/irq_regs.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-05-13 02:21:01 +07:00
|
|
|
#include "sched_cpupri.h"
|
|
|
|
|
2009-04-10 20:36:00 +07:00
|
|
|
#define CREATE_TRACE_POINTS
|
2009-04-15 06:39:12 +07:00
|
|
|
#include <trace/events/sched.h>
|
2009-04-10 20:36:00 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Convert user-nice values [ -20 ... 0 ... 19 ]
|
|
|
|
* to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
|
|
|
|
* and back.
|
|
|
|
*/
|
|
|
|
#define NICE_TO_PRIO(nice) (MAX_RT_PRIO + (nice) + 20)
|
|
|
|
#define PRIO_TO_NICE(prio) ((prio) - MAX_RT_PRIO - 20)
|
|
|
|
#define TASK_NICE(p) PRIO_TO_NICE((p)->static_prio)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'User priority' is the nice value converted to something we
|
|
|
|
* can work with better when scaling various scheduler parameters,
|
|
|
|
* it's a [ 0 ... 39 ] range.
|
|
|
|
*/
|
|
|
|
#define USER_PRIO(p) ((p)-MAX_RT_PRIO)
|
|
|
|
#define TASK_USER_PRIO(p) USER_PRIO((p)->static_prio)
|
|
|
|
#define MAX_USER_PRIO (USER_PRIO(MAX_PRIO))
|
|
|
|
|
|
|
|
/*
|
2008-01-26 03:08:19 +07:00
|
|
|
* Helpers for converting nanosecond timing to jiffy resolution
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-11-10 04:39:38 +07:00
|
|
|
#define NS_TO_JIFFIES(TIME) ((unsigned long)(TIME) / (NSEC_PER_SEC / HZ))
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:58 +07:00
|
|
|
#define NICE_0_LOAD SCHED_LOAD_SCALE
|
|
|
|
#define NICE_0_SHIFT SCHED_LOAD_SHIFT
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* These are the 'tuning knobs' of the scheduler:
|
|
|
|
*
|
2007-10-15 22:00:13 +07:00
|
|
|
* default timeslice is 100 msecs (used only for SCHED_RR tasks).
|
2005-04-17 05:20:36 +07:00
|
|
|
* Timeslices get refilled after they expire.
|
|
|
|
*/
|
|
|
|
#define DEF_TIMESLICE (100 * HZ / 1000)
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
/*
|
|
|
|
* single value that denotes runtime == period, ie unlimited time.
|
|
|
|
*/
|
|
|
|
#define RUNTIME_INF ((u64)~0ULL)
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
static inline int rt_policy(int policy)
|
|
|
|
{
|
2008-05-14 04:44:11 +07:00
|
|
|
if (unlikely(policy == SCHED_FIFO || policy == SCHED_RR))
|
2007-07-09 23:51:59 +07:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int task_has_rt_policy(struct task_struct *p)
|
|
|
|
{
|
|
|
|
return rt_policy(p->policy);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2007-07-09 23:51:58 +07:00
|
|
|
* This is the priority-queue data structure of the RT scheduling class:
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-07-09 23:51:58 +07:00
|
|
|
struct rt_prio_array {
|
|
|
|
DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */
|
|
|
|
struct list_head queue[MAX_RT_PRIO];
|
|
|
|
};
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
struct rt_bandwidth {
|
2008-03-25 19:51:45 +07:00
|
|
|
/* nests inside the rq lock: */
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spinlock_t rt_runtime_lock;
|
2008-03-25 19:51:45 +07:00
|
|
|
ktime_t rt_period;
|
|
|
|
u64 rt_runtime;
|
|
|
|
struct hrtimer rt_period_timer;
|
2008-04-20 00:44:57 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct rt_bandwidth def_rt_bandwidth;
|
|
|
|
|
|
|
|
static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
|
|
|
|
|
|
|
|
static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
struct rt_bandwidth *rt_b =
|
|
|
|
container_of(timer, struct rt_bandwidth, rt_period_timer);
|
|
|
|
ktime_t now;
|
|
|
|
int overrun;
|
|
|
|
int idle = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
now = hrtimer_cb_get_time(timer);
|
|
|
|
overrun = hrtimer_forward(timer, now, rt_b->rt_period);
|
|
|
|
|
|
|
|
if (!overrun)
|
|
|
|
break;
|
|
|
|
|
|
|
|
idle = do_sched_rt_period_timer(rt_b, overrun);
|
|
|
|
}
|
|
|
|
|
|
|
|
return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
|
|
|
|
{
|
|
|
|
rt_b->rt_period = ns_to_ktime(period);
|
|
|
|
rt_b->rt_runtime = runtime;
|
|
|
|
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock_init(&rt_b->rt_runtime_lock);
|
2008-04-20 00:44:58 +07:00
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
hrtimer_init(&rt_b->rt_period_timer,
|
|
|
|
CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
|
|
rt_b->rt_period_timer.function = sched_rt_period_timer;
|
|
|
|
}
|
|
|
|
|
2008-09-06 04:46:19 +07:00
|
|
|
static inline int rt_bandwidth_enabled(void)
|
|
|
|
{
|
|
|
|
return sysctl_sched_rt_runtime >= 0;
|
2008-04-20 00:44:57 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
|
|
|
|
{
|
|
|
|
ktime_t now;
|
|
|
|
|
2009-02-26 00:59:26 +07:00
|
|
|
if (!rt_bandwidth_enabled() || rt_b->rt_runtime == RUNTIME_INF)
|
2008-04-20 00:44:57 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (hrtimer_active(&rt_b->rt_period_timer))
|
|
|
|
return;
|
|
|
|
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock(&rt_b->rt_runtime_lock);
|
2008-04-20 00:44:57 +07:00
|
|
|
for (;;) {
|
2009-03-13 18:21:27 +07:00
|
|
|
unsigned long delta;
|
|
|
|
ktime_t soft, hard;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
if (hrtimer_active(&rt_b->rt_period_timer))
|
|
|
|
break;
|
|
|
|
|
|
|
|
now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
|
|
|
|
hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
|
2009-03-13 18:21:27 +07:00
|
|
|
|
|
|
|
soft = hrtimer_get_softexpires(&rt_b->rt_period_timer);
|
|
|
|
hard = hrtimer_get_expires(&rt_b->rt_period_timer);
|
|
|
|
delta = ktime_to_ns(ktime_sub(hard, soft));
|
|
|
|
__hrtimer_start_range_ns(&rt_b->rt_period_timer, soft, delta,
|
2009-04-16 13:44:37 +07:00
|
|
|
HRTIMER_MODE_ABS_PINNED, 0);
|
2008-04-20 00:44:57 +07:00
|
|
|
}
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_unlock(&rt_b->rt_runtime_lock);
|
2008-04-20 00:44:57 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
|
|
|
|
{
|
|
|
|
hrtimer_cancel(&rt_b->rt_period_timer);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-04-28 16:33:07 +07:00
|
|
|
/*
|
|
|
|
* sched_domains_mutex serializes calls to arch_init_sched_domains,
|
|
|
|
* detach_destroy_domains and partition_sched_domains.
|
|
|
|
*/
|
|
|
|
static DEFINE_MUTEX(sched_domains_mutex);
|
|
|
|
|
2010-01-20 19:26:18 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2007-10-19 13:41:03 +07:00
|
|
|
#include <linux/cgroup.h>
|
|
|
|
|
2007-10-15 22:00:07 +07:00
|
|
|
struct cfs_rq;
|
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
static LIST_HEAD(task_groups);
|
|
|
|
|
2007-10-15 22:00:07 +07:00
|
|
|
/* task group related information */
|
2007-10-15 22:00:14 +07:00
|
|
|
struct task_group {
|
2007-10-19 13:41:03 +07:00
|
|
|
struct cgroup_subsys_state css;
|
2008-12-01 22:19:05 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2007-10-15 22:00:07 +07:00
|
|
|
/* schedulable entities of this group on each cpu */
|
|
|
|
struct sched_entity **se;
|
|
|
|
/* runqueue "owned" by this group on each cpu */
|
|
|
|
struct cfs_rq **cfs_rq;
|
|
|
|
unsigned long shares;
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
struct sched_rt_entity **rt_se;
|
|
|
|
struct rt_rq **rt_rq;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
struct rt_bandwidth rt_bandwidth;
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
sched: group scheduler, fix fairness of cpu bandwidth allocation for task groups
The current load balancing scheme isn't good enough for precise
group fairness.
For example: on a 8-cpu system, I created 3 groups as under:
a = 8 tasks (cpu.shares = 1024)
b = 4 tasks (cpu.shares = 1024)
c = 3 tasks (cpu.shares = 1024)
a, b and c are task groups that have equal weight. We would expect each
of the groups to receive 33.33% of cpu bandwidth under a fair scheduler.
This is what I get with the latest scheduler git tree:
Signed-off-by: Ingo Molnar <mingo@elte.hu>
--------------------------------------------------------------------------------
Col1 | Col2 | Col3 | Col4
------|---------|-------|-------------------------------------------------------
a | 277.676 | 57.8% | 54.1% 54.1% 54.1% 54.2% 56.7% 62.2% 62.8% 64.5%
b | 116.108 | 24.2% | 47.4% 48.1% 48.7% 49.3%
c | 86.326 | 18.0% | 47.5% 47.9% 48.5%
--------------------------------------------------------------------------------
Explanation of o/p:
Col1 -> Group name
Col2 -> Cumulative execution time (in seconds) received by all tasks of that
group in a 60sec window across 8 cpus
Col3 -> CPU bandwidth received by the group in the 60sec window, expressed in
percentage. Col3 data is derived as:
Col3 = 100 * Col2 / (NR_CPUS * 60)
Col4 -> CPU bandwidth received by each individual task of the group.
Col4 = 100 * cpu_time_recd_by_task / 60
[I can share the test case that produces a similar o/p if reqd]
The deviation from desired group fairness is as below:
a = +24.47%
b = -9.13%
c = -15.33%
which is quite high.
After the patch below is applied, here are the results:
--------------------------------------------------------------------------------
Col1 | Col2 | Col3 | Col4
------|---------|-------|-------------------------------------------------------
a | 163.112 | 34.0% | 33.2% 33.4% 33.5% 33.5% 33.7% 34.4% 34.8% 35.3%
b | 156.220 | 32.5% | 63.3% 64.5% 66.1% 66.5%
c | 160.653 | 33.5% | 85.8% 90.6% 91.4%
--------------------------------------------------------------------------------
Deviation from desired group fairness is as below:
a = +0.67%
b = -0.83%
c = +0.17%
which is far better IMO. Most of other runs have yielded a deviation within
+-2% at the most, which is good.
Why do we see bad (group) fairness with current scheuler?
=========================================================
Currently cpu's weight is just the summation of individual task weights.
This can yield incorrect results. For ex: consider three groups as below
on a 2-cpu system:
CPU0 CPU1
---------------------------
A (10) B(5)
C(5)
---------------------------
Group A has 10 tasks, all on CPU0, Group B and C have 5 tasks each all
of which are on CPU1. Each task has the same weight (NICE_0_LOAD =
1024).
The current scheme would yield a cpu weight of 10240 (10*1024) for each cpu and
the load balancer will think both CPUs are perfectly balanced and won't
move around any tasks. This, however, would yield this bandwidth:
A = 50%
B = 25%
C = 25%
which is not the desired result.
What's changing in the patch?
=============================
- How cpu weights are calculated when CONFIF_FAIR_GROUP_SCHED is
defined (see below)
- API Change
- Two tunables introduced in sysfs (under SCHED_DEBUG) to
control the frequency at which the load balance monitor
thread runs.
The basic change made in this patch is how cpu weight (rq->load.weight) is
calculated. Its now calculated as the summation of group weights on a cpu,
rather than summation of task weights. Weight exerted by a group on a
cpu is dependent on the shares allocated to it and also the number of
tasks the group has on that cpu compared to the total number of
(runnable) tasks the group has in the system.
Let,
W(K,i) = Weight of group K on cpu i
T(K,i) = Task load present in group K's cfs_rq on cpu i
T(K) = Total task load of group K across various cpus
S(K) = Shares allocated to group K
NRCPUS = Number of online cpus in the scheduler domain to
which group K is assigned.
Then,
W(K,i) = S(K) * NRCPUS * T(K,i) / T(K)
A load balance monitor thread is created at bootup, which periodically
runs and adjusts group's weight on each cpu. To avoid its overhead, two
min/max tunables are introduced (under SCHED_DEBUG) to control the rate
at which it runs.
Fixes from: Peter Zijlstra <a.p.zijlstra@chello.nl>
- don't start the load_balance_monitor when there is only a single cpu.
- rename the kthread because its currently longer than TASK_COMM_LEN
Signed-off-by: Srivatsa Vaddagiri <vatsa@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-01-26 03:08:00 +07:00
|
|
|
|
2007-10-30 03:18:11 +07:00
|
|
|
struct rcu_head rcu;
|
2008-01-26 03:08:30 +07:00
|
|
|
struct list_head list;
|
2008-04-20 00:45:00 +07:00
|
|
|
|
|
|
|
struct task_group *parent;
|
|
|
|
struct list_head siblings;
|
|
|
|
struct list_head children;
|
2007-10-15 22:00:07 +07:00
|
|
|
};
|
|
|
|
|
2008-04-20 00:45:00 +07:00
|
|
|
#define root_task_group init_task_group
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
/* task_group_lock serializes add/remove of task groups and also changes to
|
2008-01-26 03:07:59 +07:00
|
|
|
* a task group's cpu shares.
|
|
|
|
*/
|
2008-02-13 21:45:39 +07:00
|
|
|
static DEFINE_SPINLOCK(task_group_lock);
|
2008-01-26 03:07:59 +07:00
|
|
|
|
2009-10-27 02:24:14 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
2009-03-09 19:56:21 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static int root_task_group_empty(void)
|
|
|
|
{
|
|
|
|
return list_empty(&root_task_group.children);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
# define INIT_TASK_GROUP_LOAD NICE_0_LOAD
|
|
|
|
|
sched: fair-group: fix a Div0 error of the fair group scheduler
When I echoed 0 into the "cpu.shares" file, a Div0 error occured.
We found it is caused by the following calling.
sched_group_set_shares(tg, shares)
set_se_shares(tg->se[i], shares/nr_cpu_ids)
__set_se_shares(se, shares)
div64_64((1ULL<<32), shares)
When the echoed value was less than the number of processores, the result of the
sentence "shares/nr_cpu_ids" was 0, and then the system called div64() to divide
the result, the Div0 error occured.
It is unnecessary that the shares value is divided by nr_cpu_ids, I think.
Because in the function __update_group_shares_cpu() and init_tg_cfs_entry(),
the shares value isn't divided by nr_cpu_ids when setting shares of the sched
entity.
This patch fixes this bug. And echoing ULONG_MAX value into cpu.shares also
causes Div0 error, so we set a macro MAX_SHARES to limit the max value of
shares.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-04-28 11:54:56 +07:00
|
|
|
/*
|
sched: fair group: fix overflow(was: fix divide by zero)
I found a bug which can be reproduced by this way:(linux-2.6.26-rc5, x86-64)
(use 2^32, 2^33, ...., 2^63 as shares value)
# mkdir /dev/cpuctl
# mount -t cgroup -o cpu cpuctl /dev/cpuctl
# cd /dev/cpuctl
# mkdir sub
# echo 0x8000000000000000 > sub/cpu.shares
# echo $$ > sub/tasks
oops here! divide by zero.
This is because do_div() expects the 2th parameter to be 32 bits,
but unsigned long is 64 bits in x86_64.
Peter Zijstra pointed it out that the sane thing to do is limit the
shares value to something smaller instead of using an even more
expensive divide.
Also, I found another bug about "the shares value is too large":
pid1 and pid2 are set affinity to cpu#0
pid1 is attached to cg1 and pid2 is attached to cg2
if cg1/cpu.shares = 1024 cg2/cpu.shares = 2000000000
then pid2 got 100% usage of cpu, and pid1 0%
if cg1/cpu.shares = 1024 cg2/cpu.shares = 20000000000
then pid2 got 0% usage of cpu, and pid1 100%
And a weight of a cfs_rq is the sum of weights of which entities
are queued on this cfs_rq, so the shares value should be limited
to a smaller value.
I think that (1UL << 18) is a good limited value:
1) it's not too large, we can create a lot of group before overflow
2) it's several times the weight value for nice=-19 (not too small)
Signed-off-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-06-12 15:42:58 +07:00
|
|
|
* A weight of 0 or 1 can cause arithmetics problems.
|
|
|
|
* A weight of a cfs_rq is the sum of weights of which entities
|
|
|
|
* are queued on this cfs_rq, so a weight of a entity should not be
|
|
|
|
* too large, so as the shares value of a task group.
|
sched: fair-group: fix a Div0 error of the fair group scheduler
When I echoed 0 into the "cpu.shares" file, a Div0 error occured.
We found it is caused by the following calling.
sched_group_set_shares(tg, shares)
set_se_shares(tg->se[i], shares/nr_cpu_ids)
__set_se_shares(se, shares)
div64_64((1ULL<<32), shares)
When the echoed value was less than the number of processores, the result of the
sentence "shares/nr_cpu_ids" was 0, and then the system called div64() to divide
the result, the Div0 error occured.
It is unnecessary that the shares value is divided by nr_cpu_ids, I think.
Because in the function __update_group_shares_cpu() and init_tg_cfs_entry(),
the shares value isn't divided by nr_cpu_ids when setting shares of the sched
entity.
This patch fixes this bug. And echoing ULONG_MAX value into cpu.shares also
causes Div0 error, so we set a macro MAX_SHARES to limit the max value of
shares.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-04-28 11:54:56 +07:00
|
|
|
* (The default weight is 1024 - so there's no practical
|
|
|
|
* limitation from this.)
|
|
|
|
*/
|
2008-04-20 00:45:00 +07:00
|
|
|
#define MIN_SHARES 2
|
sched: fair group: fix overflow(was: fix divide by zero)
I found a bug which can be reproduced by this way:(linux-2.6.26-rc5, x86-64)
(use 2^32, 2^33, ...., 2^63 as shares value)
# mkdir /dev/cpuctl
# mount -t cgroup -o cpu cpuctl /dev/cpuctl
# cd /dev/cpuctl
# mkdir sub
# echo 0x8000000000000000 > sub/cpu.shares
# echo $$ > sub/tasks
oops here! divide by zero.
This is because do_div() expects the 2th parameter to be 32 bits,
but unsigned long is 64 bits in x86_64.
Peter Zijstra pointed it out that the sane thing to do is limit the
shares value to something smaller instead of using an even more
expensive divide.
Also, I found another bug about "the shares value is too large":
pid1 and pid2 are set affinity to cpu#0
pid1 is attached to cg1 and pid2 is attached to cg2
if cg1/cpu.shares = 1024 cg2/cpu.shares = 2000000000
then pid2 got 100% usage of cpu, and pid1 0%
if cg1/cpu.shares = 1024 cg2/cpu.shares = 20000000000
then pid2 got 0% usage of cpu, and pid1 100%
And a weight of a cfs_rq is the sum of weights of which entities
are queued on this cfs_rq, so the shares value should be limited
to a smaller value.
I think that (1UL << 18) is a good limited value:
1) it's not too large, we can create a lot of group before overflow
2) it's several times the weight value for nice=-19 (not too small)
Signed-off-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-06-12 15:42:58 +07:00
|
|
|
#define MAX_SHARES (1UL << 18)
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
static int init_task_group_load = INIT_TASK_GROUP_LOAD;
|
|
|
|
#endif
|
|
|
|
|
2007-10-15 22:00:07 +07:00
|
|
|
/* Default task group.
|
2007-10-15 22:00:12 +07:00
|
|
|
* Every task in system belong to this group at bootup.
|
2007-10-15 22:00:07 +07:00
|
|
|
*/
|
2008-04-05 08:11:04 +07:00
|
|
|
struct task_group init_task_group;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2010-01-20 19:26:18 +07:00
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2007-07-09 23:51:58 +07:00
|
|
|
/* CFS-related fields in a runqueue */
|
|
|
|
struct cfs_rq {
|
|
|
|
struct load_weight load;
|
|
|
|
unsigned long nr_running;
|
|
|
|
|
|
|
|
u64 exec_clock;
|
2007-10-15 22:00:04 +07:00
|
|
|
u64 min_vruntime;
|
2007-07-09 23:51:58 +07:00
|
|
|
|
|
|
|
struct rb_root tasks_timeline;
|
|
|
|
struct rb_node *rb_leftmost;
|
2008-04-20 00:45:00 +07:00
|
|
|
|
|
|
|
struct list_head tasks;
|
|
|
|
struct list_head *balance_iterator;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 'curr' points to currently running entity on this cfs_rq.
|
2007-07-09 23:51:58 +07:00
|
|
|
* It is set to NULL otherwise (i.e when none are currently running).
|
|
|
|
*/
|
sched: backward looking buddy
Impact: improve/change/fix wakeup-buddy scheduling
Currently we only have a forward looking buddy, that is, we prefer to
schedule to the task we last woke up, under the presumption that its
going to consume the data we just produced, and therefore will have
cache hot benefits.
This allows co-waking producer/consumer task pairs to run ahead of the
pack for a little while, keeping their cache warm. Without this, we
would interleave all pairs, utterly trashing the cache.
This patch introduces a backward looking buddy, that is, suppose that
in the above scenario, the consumer preempts the producer before it
can go to sleep, we will therefore miss the wakeup from consumer to
producer (its already running, after all), breaking the cycle and
reverting to the cache-trashing interleaved schedule pattern.
The backward buddy will try to schedule back to the task that woke us
up in case the forward buddy is not available, under the assumption
that the last task will be the one with the most cache hot task around
barring current.
This will basically allow a task to continue after it got preempted.
In order to avoid starvation, we allow either buddy to get wakeup_gran
ahead of the pack.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Mike Galbraith <efault@gmx.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-05 03:25:09 +07:00
|
|
|
struct sched_entity *curr, *next, *last;
|
2007-10-15 22:00:10 +07:00
|
|
|
|
2008-11-10 16:46:32 +07:00
|
|
|
unsigned int nr_spread_over;
|
2007-10-15 22:00:10 +07:00
|
|
|
|
2007-10-15 22:00:03 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2007-07-09 23:51:58 +07:00
|
|
|
struct rq *rq; /* cpu runqueue to which this cfs_rq is attached */
|
|
|
|
|
2007-12-05 21:46:09 +07:00
|
|
|
/*
|
|
|
|
* leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
|
2007-07-09 23:51:58 +07:00
|
|
|
* a hierarchy). Non-leaf lrqs hold other higher schedulable entities
|
|
|
|
* (like users, containers etc.)
|
|
|
|
*
|
|
|
|
* leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
|
|
|
|
* list is used during load balance.
|
|
|
|
*/
|
2007-12-05 21:46:09 +07:00
|
|
|
struct list_head leaf_cfs_rq_list;
|
|
|
|
struct task_group *tg; /* group that "owns" this runqueue */
|
2008-06-27 18:41:14 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
2008-06-27 18:41:23 +07:00
|
|
|
* the part of load.weight contributed by tasks
|
2008-06-27 18:41:14 +07:00
|
|
|
*/
|
2008-06-27 18:41:23 +07:00
|
|
|
unsigned long task_weight;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
/*
|
|
|
|
* h_load = weight * f(tg)
|
|
|
|
*
|
|
|
|
* Where f(tg) is the recursive weight fraction assigned to
|
|
|
|
* this group.
|
|
|
|
*/
|
|
|
|
unsigned long h_load;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
/*
|
|
|
|
* this cpu's part of tg->shares
|
|
|
|
*/
|
|
|
|
unsigned long shares;
|
2008-06-27 18:41:38 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* load.weight at the time we set shares
|
|
|
|
*/
|
|
|
|
unsigned long rq_weight;
|
2008-06-27 18:41:14 +07:00
|
|
|
#endif
|
2007-07-09 23:51:58 +07:00
|
|
|
#endif
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:58 +07:00
|
|
|
/* Real-Time classes' related field in a runqueue: */
|
|
|
|
struct rt_rq {
|
|
|
|
struct rt_prio_array active;
|
2008-01-26 03:08:03 +07:00
|
|
|
unsigned long rt_nr_running;
|
2008-02-13 21:45:40 +07:00
|
|
|
#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
|
2008-12-29 21:39:49 +07:00
|
|
|
struct {
|
|
|
|
int curr; /* highest queued rt task prio */
|
2009-01-14 21:10:04 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2008-12-29 21:39:49 +07:00
|
|
|
int next; /* next highest */
|
2009-01-14 21:10:04 +07:00
|
|
|
#endif
|
2008-12-29 21:39:49 +07:00
|
|
|
} highest_prio;
|
2008-01-26 03:08:30 +07:00
|
|
|
#endif
|
2008-01-26 03:08:29 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2008-01-26 03:08:07 +07:00
|
|
|
unsigned long rt_nr_migratory;
|
2009-04-01 23:40:15 +07:00
|
|
|
unsigned long rt_nr_total;
|
2008-01-26 03:08:12 +07:00
|
|
|
int overloaded;
|
sched: create "pushable_tasks" list to limit pushing to one attempt
The RT scheduler employs a "push/pull" design to actively balance tasks
within the system (on a per disjoint cpuset basis). When a task is
awoken, it is immediately determined if there are any lower priority
cpus which should be preempted. This is opposed to the way normal
SCHED_OTHER tasks behave, which will wait for a periodic rebalancing
operation to occur before spreading out load.
When a particular RQ has more than 1 active RT task, it is said to
be in an "overloaded" state. Once this occurs, the system enters
the active balancing mode, where it will try to push the task away,
or persuade a different cpu to pull it over. The system will stay
in this state until the system falls back below the <= 1 queued RT
task per RQ.
However, the current implementation suffers from a limitation in the
push logic. Once overloaded, all tasks (other than current) on the
RQ are analyzed on every push operation, even if it was previously
unpushable (due to affinity, etc). Whats more, the operation stops
at the first task that is unpushable and will not look at items
lower in the queue. This causes two problems:
1) We can have the same tasks analyzed over and over again during each
push, which extends out the fast path in the scheduler for no
gain. Consider a RQ that has dozens of tasks that are bound to a
core. Each one of those tasks will be encountered and skipped
for each push operation while they are queued.
2) There may be lower-priority tasks under the unpushable task that
could have been successfully pushed, but will never be considered
until either the unpushable task is cleared, or a pull operation
succeeds. The net result is a potential latency source for mid
priority tasks.
This patch aims to rectify these two conditions by introducing a new
priority sorted list: "pushable_tasks". A task is added to the list
each time a task is activated or preempted. It is removed from the
list any time it is deactivated, made current, or fails to push.
This works because a task only needs to be attempted to push once.
After an initial failure to push, the other cpus will eventually try to
pull the task when the conditions are proper. This also solves the
problem that we don't completely analyze all tasks due to encountering
an unpushable tasks. Now every task will have a push attempted (when
appropriate).
This reduces latency both by shorting the critical section of the
rq->lock for certain workloads, and by making sure the algorithm
considers all eligible tasks in the system.
[ rostedt: added a couple more BUG_ONs ]
Signed-off-by: Gregory Haskins <ghaskins@novell.com>
Acked-by: Steven Rostedt <srostedt@redhat.com>
2008-12-29 21:39:53 +07:00
|
|
|
struct plist_head pushable_tasks;
|
2008-01-26 03:08:29 +07:00
|
|
|
#endif
|
2008-01-26 03:08:30 +07:00
|
|
|
int rt_throttled;
|
2008-01-26 03:08:29 +07:00
|
|
|
u64 rt_time;
|
2008-04-20 00:44:58 +07:00
|
|
|
u64 rt_runtime;
|
2008-03-25 19:51:45 +07:00
|
|
|
/* Nests inside the rq lock: */
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spinlock_t rt_runtime_lock;
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-02-13 21:45:39 +07:00
|
|
|
unsigned long rt_nr_boosted;
|
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
struct rq *rq;
|
|
|
|
struct list_head leaf_rt_rq_list;
|
|
|
|
struct task_group *tg;
|
|
|
|
#endif
|
2007-07-09 23:51:58 +07:00
|
|
|
};
|
|
|
|
|
2008-01-26 03:08:18 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We add the notion of a root-domain which will be used to define per-domain
|
2008-01-26 03:08:19 +07:00
|
|
|
* variables. Each exclusive cpuset essentially defines an island domain by
|
|
|
|
* fully partitioning the member cpus from any other cpuset. Whenever a new
|
2008-01-26 03:08:18 +07:00
|
|
|
* exclusive cpuset is created, we also create and attach a new root-domain
|
|
|
|
* object.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct root_domain {
|
|
|
|
atomic_t refcount;
|
2008-11-24 23:05:05 +07:00
|
|
|
cpumask_var_t span;
|
|
|
|
cpumask_var_t online;
|
2008-01-26 03:08:18 +07:00
|
|
|
|
2008-01-26 03:08:19 +07:00
|
|
|
/*
|
2008-01-26 03:08:18 +07:00
|
|
|
* The "RT overload" flag: it gets set if a CPU has more than
|
|
|
|
* one runnable RT task.
|
|
|
|
*/
|
2008-11-24 23:05:05 +07:00
|
|
|
cpumask_var_t rto_mask;
|
2008-01-26 03:08:19 +07:00
|
|
|
atomic_t rto_count;
|
2008-05-13 02:21:01 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
struct cpupri cpupri;
|
|
|
|
#endif
|
2008-01-26 03:08:18 +07:00
|
|
|
};
|
|
|
|
|
2008-01-26 03:08:26 +07:00
|
|
|
/*
|
|
|
|
* By default the system creates a single root-domain with all cpus as
|
|
|
|
* members (mimicking the global state we have today).
|
|
|
|
*/
|
2008-01-26 03:08:18 +07:00
|
|
|
static struct root_domain def_root_domain;
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* This is the main, per-CPU runqueue data structure.
|
|
|
|
*
|
|
|
|
* Locking rule: those places that want to lock multiple runqueues
|
|
|
|
* (such as the load balancing or the thread migration code), lock
|
|
|
|
* acquire operations must be ordered by ascending &runqueue.
|
|
|
|
*/
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq {
|
2007-10-19 02:32:55 +07:00
|
|
|
/* runqueue lock: */
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spinlock_t lock;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* nr_running and cpu_load should be in the same cacheline because
|
|
|
|
* remote CPUs use both these fields when doing load calculation.
|
|
|
|
*/
|
|
|
|
unsigned long nr_running;
|
2007-07-09 23:51:58 +07:00
|
|
|
#define CPU_LOAD_IDX_MAX 5
|
|
|
|
unsigned long cpu_load[CPU_LOAD_IDX_MAX];
|
2007-05-08 14:32:51 +07:00
|
|
|
#ifdef CONFIG_NO_HZ
|
2010-03-11 23:17:13 +07:00
|
|
|
u64 nohz_stamp;
|
2007-05-08 14:32:51 +07:00
|
|
|
unsigned char in_nohz_recently;
|
|
|
|
#endif
|
2010-03-11 23:16:20 +07:00
|
|
|
unsigned int skip_clock_update;
|
|
|
|
|
2007-10-19 02:32:55 +07:00
|
|
|
/* capture load from *all* tasks on this cpu: */
|
|
|
|
struct load_weight load;
|
2007-07-09 23:51:58 +07:00
|
|
|
unsigned long nr_load_updates;
|
|
|
|
u64 nr_switches;
|
|
|
|
|
|
|
|
struct cfs_rq cfs;
|
2008-01-26 03:08:30 +07:00
|
|
|
struct rt_rq rt;
|
|
|
|
|
2007-07-09 23:51:58 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2007-10-19 02:32:55 +07:00
|
|
|
/* list of leaf cfs_rq on this cpu: */
|
|
|
|
struct list_head leaf_cfs_rq_list;
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-01-26 03:08:30 +07:00
|
|
|
struct list_head leaf_rt_rq_list;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is part of a global counter where only the total sum
|
|
|
|
* over all CPUs matters. A task can increase this counter on
|
|
|
|
* one CPU and if it got migrated afterwards it may decrease
|
|
|
|
* it on another CPU. Always updated under the runqueue lock:
|
|
|
|
*/
|
|
|
|
unsigned long nr_uninterruptible;
|
|
|
|
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *curr, *idle;
|
2006-12-10 17:20:25 +07:00
|
|
|
unsigned long next_balance;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct mm_struct *prev_mm;
|
2007-07-09 23:51:58 +07:00
|
|
|
|
2008-05-03 23:29:28 +07:00
|
|
|
u64 clock;
|
2007-07-09 23:51:58 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_t nr_iowait;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2008-01-26 03:08:19 +07:00
|
|
|
struct root_domain *rd;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct sched_domain *sd;
|
|
|
|
|
2010-05-31 17:37:30 +07:00
|
|
|
unsigned long cpu_power;
|
|
|
|
|
2009-02-14 02:35:45 +07:00
|
|
|
unsigned char idle_at_tick;
|
2005-04-17 05:20:36 +07:00
|
|
|
/* For active balancing */
|
2009-07-29 22:08:47 +07:00
|
|
|
int post_schedule;
|
2005-04-17 05:20:36 +07:00
|
|
|
int active_balance;
|
|
|
|
int push_cpu;
|
2010-05-06 23:49:21 +07:00
|
|
|
struct cpu_stop_work active_balance_work;
|
2007-10-19 02:32:55 +07:00
|
|
|
/* cpu of this runqueue: */
|
|
|
|
int cpu;
|
2008-06-05 02:04:05 +07:00
|
|
|
int online;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-06-27 18:41:26 +07:00
|
|
|
unsigned long avg_load_per_task;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-01 15:34:37 +07:00
|
|
|
u64 rt_avg;
|
|
|
|
u64 age_stamp;
|
2009-11-04 23:53:50 +07:00
|
|
|
u64 idle_stamp;
|
|
|
|
u64 avg_idle;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
/* calc_load related fields */
|
|
|
|
unsigned long calc_load_update;
|
|
|
|
long calc_load_active;
|
|
|
|
|
2008-01-26 03:08:29 +07:00
|
|
|
#ifdef CONFIG_SCHED_HRTICK
|
2008-07-18 23:01:23 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
int hrtick_csd_pending;
|
|
|
|
struct call_single_data hrtick_csd;
|
|
|
|
#endif
|
2008-01-26 03:08:29 +07:00
|
|
|
struct hrtimer hrtick_timer;
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
|
|
/* latency stats */
|
|
|
|
struct sched_info rq_sched_info;
|
2008-12-17 14:41:22 +07:00
|
|
|
unsigned long long rq_cpu_time;
|
|
|
|
/* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* sys_sched_yield() stats */
|
2007-10-19 02:32:56 +07:00
|
|
|
unsigned int yld_count;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* schedule() stats */
|
2007-10-19 02:32:56 +07:00
|
|
|
unsigned int sched_switch;
|
|
|
|
unsigned int sched_count;
|
|
|
|
unsigned int sched_goidle;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* try_to_wake_up() stats */
|
2007-10-19 02:32:56 +07:00
|
|
|
unsigned int ttwu_count;
|
|
|
|
unsigned int ttwu_local;
|
2007-10-15 22:00:10 +07:00
|
|
|
|
|
|
|
/* BKL stats */
|
2007-10-19 02:32:56 +07:00
|
|
|
unsigned int bkl_count;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2007-07-19 15:48:13 +07:00
|
|
|
static DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-15 00:55:44 +07:00
|
|
|
static inline
|
|
|
|
void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
2009-09-15 00:55:44 +07:00
|
|
|
rq->curr->sched_class->check_preempt_curr(rq, p, flags);
|
2010-03-11 23:16:20 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A queue event has occurred, and we're going to schedule. In
|
|
|
|
* this case, we can save a useless back to back clock update.
|
|
|
|
*/
|
|
|
|
if (test_tsk_need_resched(p))
|
|
|
|
rq->skip_clock_update = 1;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2006-09-26 13:30:51 +07:00
|
|
|
static inline int cpu_of(struct rq *rq)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
return rq->cpu;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-02-23 08:04:51 +07:00
|
|
|
#define rcu_dereference_check_sched_domain(p) \
|
2010-02-23 08:04:50 +07:00
|
|
|
rcu_dereference_check((p), \
|
|
|
|
rcu_read_lock_sched_held() || \
|
|
|
|
lockdep_is_held(&sched_domains_mutex))
|
|
|
|
|
2005-06-26 04:57:27 +07:00
|
|
|
/*
|
|
|
|
* The domain tree (rq->sd) is protected by RCU's quiescent state transition.
|
2005-06-26 04:57:33 +07:00
|
|
|
* See detach_destroy_domains: synchronize_sched for details.
|
2005-06-26 04:57:27 +07:00
|
|
|
*
|
|
|
|
* The domain tree of any CPU may only be accessed from within
|
|
|
|
* preempt-disabled sections.
|
|
|
|
*/
|
2006-07-03 14:25:40 +07:00
|
|
|
#define for_each_domain(cpu, __sd) \
|
2010-02-23 08:04:51 +07:00
|
|
|
for (__sd = rcu_dereference_check_sched_domain(cpu_rq(cpu)->sd); __sd; __sd = __sd->parent)
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#define cpu_rq(cpu) (&per_cpu(runqueues, (cpu)))
|
|
|
|
#define this_rq() (&__get_cpu_var(runqueues))
|
|
|
|
#define task_rq(p) cpu_rq(task_cpu(p))
|
|
|
|
#define cpu_curr(cpu) (cpu_rq(cpu)->curr)
|
2009-06-29 12:44:57 +07:00
|
|
|
#define raw_rq() (&__raw_get_cpu_var(runqueues))
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-06-08 16:40:42 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the group to which this tasks belongs.
|
|
|
|
*
|
|
|
|
* We use task_subsys_state_check() and extend the RCU verification
|
|
|
|
* with lockdep_is_held(&task_rq(p)->lock) because cpu_cgroup_attach()
|
|
|
|
* holds that lock for each task it moves into the cgroup. Therefore
|
|
|
|
* by holding that lock, we pin the task to the current cgroup.
|
|
|
|
*/
|
|
|
|
static inline struct task_group *task_group(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct cgroup_subsys_state *css;
|
|
|
|
|
|
|
|
css = task_subsys_state_check(p, cpu_cgroup_subsys_id,
|
|
|
|
lockdep_is_held(&task_rq(p)->lock));
|
|
|
|
return container_of(css, struct task_group, css);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
|
|
|
|
static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
p->se.cfs_rq = task_group(p)->cfs_rq[cpu];
|
|
|
|
p->se.parent = task_group(p)->se[cpu];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
p->rt.rt_rq = task_group(p)->rt_rq[cpu];
|
|
|
|
p->rt.parent = task_group(p)->rt_se[cpu];
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_CGROUP_SCHED */
|
|
|
|
|
|
|
|
static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
|
|
|
|
static inline struct task_group *task_group(struct task_struct *p)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
|
|
|
|
2008-12-17 20:10:57 +07:00
|
|
|
inline void update_rq_clock(struct rq *rq)
|
2008-05-03 23:29:28 +07:00
|
|
|
{
|
2010-03-11 23:16:20 +07:00
|
|
|
if (!rq->skip_clock_update)
|
|
|
|
rq->clock = sched_clock_cpu(cpu_of(rq));
|
2008-05-03 23:29:28 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:04 +07:00
|
|
|
/*
|
|
|
|
* Tunables that become constants when CONFIG_SCHED_DEBUG is off:
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
# define const_debug __read_mostly
|
|
|
|
#else
|
|
|
|
# define const_debug static const
|
|
|
|
#endif
|
|
|
|
|
2008-05-13 02:20:52 +07:00
|
|
|
/**
|
|
|
|
* runqueue_is_locked
|
2009-10-12 09:12:00 +07:00
|
|
|
* @cpu: the processor in question.
|
2008-05-13 02:20:52 +07:00
|
|
|
*
|
|
|
|
* Returns true if the current cpu runqueue is locked.
|
|
|
|
* This interface allows printk to be called with the runqueue lock
|
|
|
|
* held and know whether or not it is OK to wake up the klogd.
|
|
|
|
*/
|
2009-09-20 01:55:44 +07:00
|
|
|
int runqueue_is_locked(int cpu)
|
2008-05-13 02:20:52 +07:00
|
|
|
{
|
2009-11-17 20:28:38 +07:00
|
|
|
return raw_spin_is_locked(&cpu_rq(cpu)->lock);
|
2008-05-13 02:20:52 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:04 +07:00
|
|
|
/*
|
|
|
|
* Debugging: various feature bits
|
|
|
|
*/
|
2008-04-20 00:45:00 +07:00
|
|
|
|
|
|
|
#define SCHED_FEAT(name, enabled) \
|
|
|
|
__SCHED_FEAT_##name ,
|
|
|
|
|
2007-10-15 22:00:04 +07:00
|
|
|
enum {
|
2008-04-20 00:45:00 +07:00
|
|
|
#include "sched_features.h"
|
2007-10-15 22:00:04 +07:00
|
|
|
};
|
|
|
|
|
2008-04-20 00:45:00 +07:00
|
|
|
#undef SCHED_FEAT
|
|
|
|
|
|
|
|
#define SCHED_FEAT(name, enabled) \
|
|
|
|
(1UL << __SCHED_FEAT_##name) * enabled |
|
|
|
|
|
2007-10-15 22:00:04 +07:00
|
|
|
const_debug unsigned int sysctl_sched_features =
|
2008-04-20 00:45:00 +07:00
|
|
|
#include "sched_features.h"
|
|
|
|
0;
|
|
|
|
|
|
|
|
#undef SCHED_FEAT
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
#define SCHED_FEAT(name, enabled) \
|
|
|
|
#name ,
|
|
|
|
|
2008-04-25 08:17:55 +07:00
|
|
|
static __read_mostly char *sched_feat_names[] = {
|
2008-04-20 00:45:00 +07:00
|
|
|
#include "sched_features.h"
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
#undef SCHED_FEAT
|
|
|
|
|
2008-10-30 14:23:32 +07:00
|
|
|
static int sched_feat_show(struct seq_file *m, void *v)
|
2008-04-20 00:45:00 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; sched_feat_names[i]; i++) {
|
2008-10-30 14:23:32 +07:00
|
|
|
if (!(sysctl_sched_features & (1UL << i)))
|
|
|
|
seq_puts(m, "NO_");
|
|
|
|
seq_printf(m, "%s ", sched_feat_names[i]);
|
2008-04-20 00:45:00 +07:00
|
|
|
}
|
2008-10-30 14:23:32 +07:00
|
|
|
seq_puts(m, "\n");
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-10-30 14:23:32 +07:00
|
|
|
return 0;
|
2008-04-20 00:45:00 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
sched_feat_write(struct file *filp, const char __user *ubuf,
|
|
|
|
size_t cnt, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[64];
|
|
|
|
char *cmp = buf;
|
|
|
|
int neg = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (cnt > 63)
|
|
|
|
cnt = 63;
|
|
|
|
|
|
|
|
if (copy_from_user(&buf, ubuf, cnt))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
buf[cnt] = 0;
|
|
|
|
|
2008-04-18 15:55:34 +07:00
|
|
|
if (strncmp(buf, "NO_", 3) == 0) {
|
2008-04-20 00:45:00 +07:00
|
|
|
neg = 1;
|
|
|
|
cmp += 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; sched_feat_names[i]; i++) {
|
|
|
|
int len = strlen(sched_feat_names[i]);
|
|
|
|
|
|
|
|
if (strncmp(cmp, sched_feat_names[i], len) == 0) {
|
|
|
|
if (neg)
|
|
|
|
sysctl_sched_features &= ~(1UL << i);
|
|
|
|
else
|
|
|
|
sysctl_sched_features |= (1UL << i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sched_feat_names[i])
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-11-20 23:40:37 +07:00
|
|
|
*ppos += cnt;
|
2008-04-20 00:45:00 +07:00
|
|
|
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2008-10-30 14:23:32 +07:00
|
|
|
static int sched_feat_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
return single_open(filp, sched_feat_show, NULL);
|
|
|
|
}
|
|
|
|
|
2009-10-02 05:43:56 +07:00
|
|
|
static const struct file_operations sched_feat_fops = {
|
2008-10-30 14:23:32 +07:00
|
|
|
.open = sched_feat_open,
|
|
|
|
.write = sched_feat_write,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2008-04-20 00:45:00 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static __init int sched_init_debug(void)
|
|
|
|
{
|
|
|
|
debugfs_create_file("sched_features", 0644, NULL, NULL,
|
|
|
|
&sched_feat_fops);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
late_initcall(sched_init_debug);
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define sched_feat(x) (sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
|
2007-10-15 22:00:04 +07:00
|
|
|
|
2007-11-10 04:39:39 +07:00
|
|
|
/*
|
|
|
|
* Number of tasks to iterate in a single balance run.
|
|
|
|
* Limited because this is done with IRQs disabled.
|
|
|
|
*/
|
|
|
|
const_debug unsigned int sysctl_sched_nr_migrate = 32;
|
|
|
|
|
2008-06-27 18:41:35 +07:00
|
|
|
/*
|
|
|
|
* ratelimit for updating the group shares.
|
2008-08-04 13:54:26 +07:00
|
|
|
* default: 0.25ms
|
2008-06-27 18:41:35 +07:00
|
|
|
*/
|
2008-08-04 13:54:26 +07:00
|
|
|
unsigned int sysctl_sched_shares_ratelimit = 250000;
|
2009-11-30 18:16:46 +07:00
|
|
|
unsigned int normalized_sysctl_sched_shares_ratelimit = 250000;
|
2008-06-27 18:41:35 +07:00
|
|
|
|
2008-10-18 00:27:02 +07:00
|
|
|
/*
|
|
|
|
* Inject some fuzzyness into changing the per-cpu group shares
|
|
|
|
* this avoids remote rq-locks at the expense of fairness.
|
|
|
|
* default: 4
|
|
|
|
*/
|
|
|
|
unsigned int sysctl_sched_shares_thresh = 4;
|
|
|
|
|
2009-09-01 15:34:37 +07:00
|
|
|
/*
|
|
|
|
* period over which we average the RT time consumption, measured
|
|
|
|
* in ms.
|
|
|
|
*
|
|
|
|
* default: 1s
|
|
|
|
*/
|
|
|
|
const_debug unsigned int sysctl_sched_time_avg = MSEC_PER_SEC;
|
|
|
|
|
2008-01-26 03:08:29 +07:00
|
|
|
/*
|
2008-02-13 21:45:39 +07:00
|
|
|
* period over which we measure -rt task cpu usage in us.
|
2008-01-26 03:08:29 +07:00
|
|
|
* default: 1s
|
|
|
|
*/
|
2008-02-13 21:45:39 +07:00
|
|
|
unsigned int sysctl_sched_rt_period = 1000000;
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2008-02-13 20:02:36 +07:00
|
|
|
static __read_mostly int scheduler_running;
|
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
/*
|
|
|
|
* part of the period that we allow rt tasks to run in us.
|
|
|
|
* default: 0.95s
|
|
|
|
*/
|
|
|
|
int sysctl_sched_rt_runtime = 950000;
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
static inline u64 global_rt_period(void)
|
|
|
|
{
|
|
|
|
return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 global_rt_runtime(void)
|
|
|
|
{
|
2008-07-23 03:51:15 +07:00
|
|
|
if (sysctl_sched_rt_runtime < 0)
|
2008-04-20 00:44:57 +07:00
|
|
|
return RUNTIME_INF;
|
|
|
|
|
|
|
|
return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
|
|
|
|
}
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifndef prepare_arch_switch
|
2005-06-26 04:57:23 +07:00
|
|
|
# define prepare_arch_switch(next) do { } while (0)
|
|
|
|
#endif
|
|
|
|
#ifndef finish_arch_switch
|
|
|
|
# define finish_arch_switch(prev) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2007-12-18 21:21:13 +07:00
|
|
|
static inline int task_current(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
return rq->curr == p;
|
|
|
|
}
|
|
|
|
|
2005-06-26 04:57:23 +07:00
|
|
|
#ifndef __ARCH_WANT_UNLOCKED_CTXSW
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline int task_running(struct rq *rq, struct task_struct *p)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
2007-12-18 21:21:13 +07:00
|
|
|
return task_current(rq, p);
|
2005-06-26 04:57:23 +07:00
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
2005-09-13 16:17:59 +07:00
|
|
|
#ifdef CONFIG_DEBUG_SPINLOCK
|
|
|
|
/* this is a valid case when another task releases the spinlock */
|
|
|
|
rq->lock.owner = current;
|
|
|
|
#endif
|
2006-07-03 14:24:54 +07:00
|
|
|
/*
|
|
|
|
* If we are tracking spinlock dependencies then we have to
|
|
|
|
* fix up the runqueue lock - which gets 'carried over' from
|
|
|
|
* prev into current:
|
|
|
|
*/
|
|
|
|
spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
2005-06-26 04:57:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* __ARCH_WANT_UNLOCKED_CTXSW */
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline int task_running(struct rq *rq, struct task_struct *p)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
return p->oncpu;
|
|
|
|
#else
|
2007-12-18 21:21:13 +07:00
|
|
|
return task_current(rq, p);
|
2005-06-26 04:57:23 +07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* We can optimise this out completely for !SMP, because the
|
|
|
|
* SMP rebalancing from interrupt is the only thing that cares
|
|
|
|
* here.
|
|
|
|
*/
|
|
|
|
next->oncpu = 1;
|
|
|
|
#endif
|
|
|
|
#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
2005-06-26 04:57:23 +07:00
|
|
|
#else
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&rq->lock);
|
2005-06-26 04:57:23 +07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* After ->oncpu is cleared, the task can be moved to a different CPU.
|
|
|
|
* We must ensure this doesn't happen until the switch is completely
|
|
|
|
* finished.
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
|
|
|
prev->oncpu = 0;
|
|
|
|
#endif
|
|
|
|
#ifndef __ARCH_WANT_INTERRUPTS_ON_CTXSW
|
|
|
|
local_irq_enable();
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2005-06-26 04:57:23 +07:00
|
|
|
}
|
|
|
|
#endif /* __ARCH_WANT_UNLOCKED_CTXSW */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-02-15 20:45:54 +07:00
|
|
|
/*
|
2010-03-26 03:05:16 +07:00
|
|
|
* Check whether the task is waking, we use this to synchronize ->cpus_allowed
|
|
|
|
* against ttwu().
|
2010-02-15 20:45:54 +07:00
|
|
|
*/
|
|
|
|
static inline int task_is_waking(struct task_struct *p)
|
|
|
|
{
|
2010-03-25 00:34:10 +07:00
|
|
|
return unlikely(p->state == TASK_WAKING);
|
2010-02-15 20:45:54 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 16:54:51 +07:00
|
|
|
/*
|
|
|
|
* __task_rq_lock - lock the runqueue a given task resides on.
|
|
|
|
* Must be called interrupts disabled.
|
|
|
|
*/
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline struct rq *__task_rq_lock(struct task_struct *p)
|
2006-06-27 16:54:51 +07:00
|
|
|
__acquires(rq->lock)
|
|
|
|
{
|
2010-02-15 20:45:54 +07:00
|
|
|
struct rq *rq;
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
for (;;) {
|
2010-02-15 20:45:54 +07:00
|
|
|
rq = task_rq(p);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
2010-03-26 03:05:16 +07:00
|
|
|
if (likely(rq == task_rq(p)))
|
2007-10-15 22:00:14 +07:00
|
|
|
return rq;
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&rq->lock);
|
2006-06-27 16:54:51 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* task_rq_lock - lock the runqueue a given task resides on and disable
|
2007-12-05 21:46:09 +07:00
|
|
|
* interrupts. Note the ordering: we can safely lookup the task_rq without
|
2005-04-17 05:20:36 +07:00
|
|
|
* explicitly disabling preemption.
|
|
|
|
*/
|
2006-07-03 14:25:42 +07:00
|
|
|
static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
__acquires(rq->lock)
|
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
for (;;) {
|
|
|
|
local_irq_save(*flags);
|
|
|
|
rq = task_rq(p);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
2010-03-26 03:05:16 +07:00
|
|
|
if (likely(rq == task_rq(p)))
|
2007-10-15 22:00:14 +07:00
|
|
|
return rq;
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, *flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:13 +07:00
|
|
|
static void __task_rq_unlock(struct rq *rq)
|
2006-06-27 16:54:51 +07:00
|
|
|
__releases(rq->lock)
|
|
|
|
{
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&rq->lock);
|
2006-06-27 16:54:51 +07:00
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:42 +07:00
|
|
|
static inline void task_rq_unlock(struct rq *rq, unsigned long *flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
__releases(rq->lock)
|
|
|
|
{
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, *flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-12-10 17:20:00 +07:00
|
|
|
* this_rq_lock - lock this runqueue and disable interrupts.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-10-15 22:00:13 +07:00
|
|
|
static struct rq *this_rq_lock(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
__acquires(rq->lock)
|
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
local_irq_disable();
|
|
|
|
rq = this_rq();
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return rq;
|
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:29 +07:00
|
|
|
#ifdef CONFIG_SCHED_HRTICK
|
|
|
|
/*
|
|
|
|
* Use HR-timers to deliver accurate preemption points.
|
|
|
|
*
|
|
|
|
* Its all a bit involved since we cannot program an hrt while holding the
|
|
|
|
* rq->lock. So what we do is store a state in in rq->hrtick_* and ask for a
|
|
|
|
* reschedule event.
|
|
|
|
*
|
|
|
|
* When we get rescheduled we reprogram the hrtick_timer outside of the
|
|
|
|
* rq->lock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use hrtick when:
|
|
|
|
* - enabled by features
|
|
|
|
* - hrtimer is actually high res
|
|
|
|
*/
|
|
|
|
static inline int hrtick_enabled(struct rq *rq)
|
|
|
|
{
|
|
|
|
if (!sched_feat(HRTICK))
|
|
|
|
return 0;
|
2008-07-20 16:02:06 +07:00
|
|
|
if (!cpu_active(cpu_of(rq)))
|
2008-04-29 15:02:46 +07:00
|
|
|
return 0;
|
2008-01-26 03:08:29 +07:00
|
|
|
return hrtimer_is_hres_active(&rq->hrtick_timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hrtick_clear(struct rq *rq)
|
|
|
|
{
|
|
|
|
if (hrtimer_active(&rq->hrtick_timer))
|
|
|
|
hrtimer_cancel(&rq->hrtick_timer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* High-resolution timer tick.
|
|
|
|
* Runs from hardirq context with interrupts disabled.
|
|
|
|
*/
|
|
|
|
static enum hrtimer_restart hrtick(struct hrtimer *timer)
|
|
|
|
{
|
|
|
|
struct rq *rq = container_of(timer, struct rq, hrtick_timer);
|
|
|
|
|
|
|
|
WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
2008-05-03 23:29:28 +07:00
|
|
|
update_rq_clock(rq);
|
2008-01-26 03:08:29 +07:00
|
|
|
rq->curr->sched_class->task_tick(rq, rq->curr, 1);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&rq->lock);
|
2008-01-26 03:08:29 +07:00
|
|
|
|
|
|
|
return HRTIMER_NORESTART;
|
|
|
|
}
|
|
|
|
|
2008-05-11 07:25:33 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2008-07-18 23:01:23 +07:00
|
|
|
/*
|
|
|
|
* called from hardirq (IPI) context
|
|
|
|
*/
|
|
|
|
static void __hrtick_start(void *arg)
|
2008-04-29 15:02:46 +07:00
|
|
|
{
|
2008-07-18 23:01:23 +07:00
|
|
|
struct rq *rq = arg;
|
2008-04-29 15:02:46 +07:00
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
2008-07-18 23:01:23 +07:00
|
|
|
hrtimer_restart(&rq->hrtick_timer);
|
|
|
|
rq->hrtick_csd_pending = 0;
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&rq->lock);
|
2008-04-29 15:02:46 +07:00
|
|
|
}
|
|
|
|
|
2008-07-18 23:01:23 +07:00
|
|
|
/*
|
|
|
|
* Called to set the hrtick timer state.
|
|
|
|
*
|
|
|
|
* called with rq->lock held and irqs disabled
|
|
|
|
*/
|
|
|
|
static void hrtick_start(struct rq *rq, u64 delay)
|
2008-04-29 15:02:46 +07:00
|
|
|
{
|
2008-07-18 23:01:23 +07:00
|
|
|
struct hrtimer *timer = &rq->hrtick_timer;
|
|
|
|
ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
|
2008-04-29 15:02:46 +07:00
|
|
|
|
2008-09-02 05:02:30 +07:00
|
|
|
hrtimer_set_expires(timer, time);
|
2008-07-18 23:01:23 +07:00
|
|
|
|
|
|
|
if (rq == this_rq()) {
|
|
|
|
hrtimer_restart(timer);
|
|
|
|
} else if (!rq->hrtick_csd_pending) {
|
2009-02-25 19:59:48 +07:00
|
|
|
__smp_call_function_single(cpu_of(rq), &rq->hrtick_csd, 0);
|
2008-07-18 23:01:23 +07:00
|
|
|
rq->hrtick_csd_pending = 1;
|
|
|
|
}
|
2008-04-29 15:02:46 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
hotplug_hrtick(struct notifier_block *nfb, unsigned long action, void *hcpu)
|
|
|
|
{
|
|
|
|
int cpu = (int)(long)hcpu;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case CPU_UP_CANCELED:
|
|
|
|
case CPU_UP_CANCELED_FROZEN:
|
|
|
|
case CPU_DOWN_PREPARE:
|
|
|
|
case CPU_DOWN_PREPARE_FROZEN:
|
|
|
|
case CPU_DEAD:
|
|
|
|
case CPU_DEAD_FROZEN:
|
2008-07-18 23:01:23 +07:00
|
|
|
hrtick_clear(cpu_rq(cpu));
|
2008-04-29 15:02:46 +07:00
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
2008-09-23 04:55:45 +07:00
|
|
|
static __init void init_hrtick(void)
|
2008-04-29 15:02:46 +07:00
|
|
|
{
|
|
|
|
hotcpu_notifier(hotplug_hrtick, 0);
|
|
|
|
}
|
2008-07-18 23:01:23 +07:00
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* Called to set the hrtick timer state.
|
|
|
|
*
|
|
|
|
* called with rq->lock held and irqs disabled
|
|
|
|
*/
|
|
|
|
static void hrtick_start(struct rq *rq, u64 delay)
|
|
|
|
{
|
2009-03-13 18:21:27 +07:00
|
|
|
__hrtimer_start_range_ns(&rq->hrtick_timer, ns_to_ktime(delay), 0,
|
2009-04-16 13:44:37 +07:00
|
|
|
HRTIMER_MODE_REL_PINNED, 0);
|
2008-07-18 23:01:23 +07:00
|
|
|
}
|
2008-04-29 15:02:46 +07:00
|
|
|
|
2008-09-23 04:55:46 +07:00
|
|
|
static inline void init_hrtick(void)
|
2008-01-26 03:08:29 +07:00
|
|
|
{
|
|
|
|
}
|
2008-07-18 23:01:23 +07:00
|
|
|
#endif /* CONFIG_SMP */
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2008-07-18 23:01:23 +07:00
|
|
|
static void init_rq_hrtick(struct rq *rq)
|
2008-01-26 03:08:29 +07:00
|
|
|
{
|
2008-07-18 23:01:23 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
rq->hrtick_csd_pending = 0;
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2008-07-18 23:01:23 +07:00
|
|
|
rq->hrtick_csd.flags = 0;
|
|
|
|
rq->hrtick_csd.func = __hrtick_start;
|
|
|
|
rq->hrtick_csd.info = rq;
|
|
|
|
#endif
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2008-07-18 23:01:23 +07:00
|
|
|
hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
|
|
|
|
rq->hrtick_timer.function = hrtick;
|
2008-01-26 03:08:29 +07:00
|
|
|
}
|
2008-09-23 04:55:46 +07:00
|
|
|
#else /* CONFIG_SCHED_HRTICK */
|
2008-01-26 03:08:29 +07:00
|
|
|
static inline void hrtick_clear(struct rq *rq)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void init_rq_hrtick(struct rq *rq)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:02:46 +07:00
|
|
|
static inline void init_hrtick(void)
|
|
|
|
{
|
|
|
|
}
|
2008-09-23 04:55:46 +07:00
|
|
|
#endif /* CONFIG_SCHED_HRTICK */
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* resched_task - mark a task 'to be rescheduled now'.
|
|
|
|
*
|
|
|
|
* On UP this means the setting of the need_resched flag, on SMP it
|
|
|
|
* might also involve a cross-CPU call to trigger the scheduler on
|
|
|
|
* the target CPU.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
|
|
|
#ifndef tsk_is_polling
|
|
|
|
#define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG)
|
|
|
|
#endif
|
|
|
|
|
2008-07-18 23:01:23 +07:00
|
|
|
static void resched_task(struct task_struct *p)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
assert_raw_spin_locked(&task_rq(p)->lock);
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2009-03-06 18:40:20 +07:00
|
|
|
if (test_tsk_need_resched(p))
|
2007-07-09 23:51:59 +07:00
|
|
|
return;
|
|
|
|
|
2009-03-06 18:40:20 +07:00
|
|
|
set_tsk_need_resched(p);
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
cpu = task_cpu(p);
|
|
|
|
if (cpu == smp_processor_id())
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* NEED_RESCHED must be visible before we test polling */
|
|
|
|
smp_mb();
|
|
|
|
if (!tsk_is_polling(p))
|
|
|
|
smp_send_reschedule(cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void resched_cpu(int cpu)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
if (!raw_spin_trylock_irqsave(&rq->lock, flags))
|
2007-07-09 23:51:59 +07:00
|
|
|
return;
|
|
|
|
resched_task(cpu_curr(cpu));
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
2008-03-22 15:20:24 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_NO_HZ
|
|
|
|
/*
|
|
|
|
* When add_timer_on() enqueues a timer into the timer wheel of an
|
|
|
|
* idle CPU then this timer might expire before the next timer event
|
|
|
|
* which is scheduled to wake up that CPU. In case of a completely
|
|
|
|
* idle system the next event might even be infinite time into the
|
|
|
|
* future. wake_up_idle_cpu() ensures that the CPU is woken up and
|
|
|
|
* leaves the inner idle loop so the newly added timer is taken into
|
|
|
|
* account when the CPU goes back to idle and evaluates the timer
|
|
|
|
* wheel for the next timer event.
|
|
|
|
*/
|
|
|
|
void wake_up_idle_cpu(int cpu)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
|
|
|
|
if (cpu == smp_processor_id())
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is safe, as this function is called with the timer
|
|
|
|
* wheel base lock of (cpu) held. When the CPU is on the way
|
|
|
|
* to idle and has not yet set rq->curr to idle then it will
|
|
|
|
* be serialized on the timer wheel base lock and take the new
|
|
|
|
* timer into account automatically.
|
|
|
|
*/
|
|
|
|
if (rq->curr != rq->idle)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can set TIF_RESCHED on the idle task of the other CPU
|
|
|
|
* lockless. The worst case is that the other CPU runs the
|
|
|
|
* idle task through an additional NOOP schedule()
|
|
|
|
*/
|
2009-03-06 18:40:20 +07:00
|
|
|
set_tsk_need_resched(rq->idle);
|
2008-03-22 15:20:24 +07:00
|
|
|
|
|
|
|
/* NEED_RESCHED must be visible before we test polling */
|
|
|
|
smp_mb();
|
|
|
|
if (!tsk_is_polling(rq->idle))
|
|
|
|
smp_send_reschedule(cpu);
|
|
|
|
}
|
2010-03-11 23:17:13 +07:00
|
|
|
|
|
|
|
int nohz_ratelimit(int cpu)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
u64 diff = rq->clock - rq->nohz_stamp;
|
|
|
|
|
|
|
|
rq->nohz_stamp = rq->clock;
|
|
|
|
|
|
|
|
return diff < (NSEC_PER_SEC / HZ) >> 1;
|
|
|
|
}
|
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_NO_HZ */
|
2008-03-22 15:20:24 +07:00
|
|
|
|
2009-09-01 15:34:37 +07:00
|
|
|
static u64 sched_avg_period(void)
|
|
|
|
{
|
|
|
|
return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sched_avg_update(struct rq *rq)
|
|
|
|
{
|
|
|
|
s64 period = sched_avg_period();
|
|
|
|
|
|
|
|
while ((s64)(rq->clock - rq->age_stamp) > period) {
|
2010-05-25 02:11:43 +07:00
|
|
|
/*
|
|
|
|
* Inline assembly required to prevent the compiler
|
|
|
|
* optimising this loop into a divmod call.
|
|
|
|
* See __iter_div_u64_rem() for another example of this.
|
|
|
|
*/
|
|
|
|
asm("" : "+rm" (rq->age_stamp));
|
2009-09-01 15:34:37 +07:00
|
|
|
rq->age_stamp += period;
|
|
|
|
rq->rt_avg /= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
|
|
|
|
{
|
|
|
|
rq->rt_avg += rt_delta;
|
|
|
|
sched_avg_update(rq);
|
|
|
|
}
|
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFIG_SMP */
|
2008-07-18 23:01:23 +07:00
|
|
|
static void resched_task(struct task_struct *p)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
2009-11-17 20:28:38 +07:00
|
|
|
assert_raw_spin_locked(&task_rq(p)->lock);
|
2008-07-18 23:01:23 +07:00
|
|
|
set_tsk_need_resched(p);
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
2009-09-01 15:34:37 +07:00
|
|
|
|
|
|
|
static void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
|
|
|
|
{
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_SMP */
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
#if BITS_PER_LONG == 32
|
|
|
|
# define WMULT_CONST (~0UL)
|
|
|
|
#else
|
|
|
|
# define WMULT_CONST (1UL << 32)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define WMULT_SHIFT 32
|
|
|
|
|
2007-08-09 16:16:51 +07:00
|
|
|
/*
|
|
|
|
* Shift right and round:
|
|
|
|
*/
|
2007-09-05 19:32:49 +07:00
|
|
|
#define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
|
2007-08-09 16:16:51 +07:00
|
|
|
|
2008-06-27 18:41:11 +07:00
|
|
|
/*
|
|
|
|
* delta *= weight / lw
|
|
|
|
*/
|
2007-08-02 22:41:40 +07:00
|
|
|
static unsigned long
|
2007-07-09 23:51:59 +07:00
|
|
|
calc_delta_mine(unsigned long delta_exec, unsigned long weight,
|
|
|
|
struct load_weight *lw)
|
|
|
|
{
|
|
|
|
u64 tmp;
|
|
|
|
|
2008-06-12 15:43:07 +07:00
|
|
|
if (!lw->inv_weight) {
|
|
|
|
if (BITS_PER_LONG > 32 && unlikely(lw->weight >= WMULT_CONST))
|
|
|
|
lw->inv_weight = 1;
|
|
|
|
else
|
|
|
|
lw->inv_weight = 1 + (WMULT_CONST-lw->weight/2)
|
|
|
|
/ (lw->weight+1);
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
tmp = (u64)delta_exec * weight;
|
|
|
|
/*
|
|
|
|
* Check whether we'd overflow the 64-bit multiplication:
|
|
|
|
*/
|
2007-08-09 16:16:51 +07:00
|
|
|
if (unlikely(tmp > WMULT_CONST))
|
2007-09-05 19:32:49 +07:00
|
|
|
tmp = SRR(SRR(tmp, WMULT_SHIFT/2) * lw->inv_weight,
|
2007-08-09 16:16:51 +07:00
|
|
|
WMULT_SHIFT/2);
|
|
|
|
else
|
2007-09-05 19:32:49 +07:00
|
|
|
tmp = SRR(tmp * lw->inv_weight, WMULT_SHIFT);
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2007-08-02 22:41:40 +07:00
|
|
|
return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:04 +07:00
|
|
|
static inline void update_load_add(struct load_weight *lw, unsigned long inc)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
|
|
|
lw->weight += inc;
|
2008-03-15 05:48:28 +07:00
|
|
|
lw->inv_weight = 0;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:04 +07:00
|
|
|
static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
|
|
|
lw->weight -= dec;
|
2008-03-15 05:48:28 +07:00
|
|
|
lw->inv_weight = 0;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
/*
|
|
|
|
* To aid in avoiding the subversion of "niceness" due to uneven distribution
|
|
|
|
* of tasks with abnormal "nice" values across CPUs the contribution that
|
|
|
|
* each task makes to its run queue's load is weighted according to its
|
2007-12-05 21:46:09 +07:00
|
|
|
* scheduling class and "nice" value. For SCHED_NORMAL tasks this is just a
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
* scaled version of the new time slice allocation that they receive on time
|
|
|
|
* slice expiry etc.
|
|
|
|
*/
|
|
|
|
|
2009-01-15 20:53:37 +07:00
|
|
|
#define WEIGHT_IDLEPRIO 3
|
|
|
|
#define WMULT_IDLEPRIO 1431655765
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Nice levels are multiplicative, with a gentle 10% change for every
|
|
|
|
* nice level changed. I.e. when a CPU-bound task goes from nice 0 to
|
|
|
|
* nice 1, it will get ~10% less CPU time than another CPU-bound task
|
|
|
|
* that remained on nice 0.
|
|
|
|
*
|
|
|
|
* The "10% effect" is relative and cumulative: from _any_ nice level,
|
|
|
|
* if you go up 1 level, it's -10% CPU usage, if you go down 1 level
|
2007-07-16 14:46:30 +07:00
|
|
|
* it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
|
|
|
|
* If a task goes up by ~10% and another task goes down by ~10% then
|
|
|
|
* the relative distance between them is ~25%.)
|
2007-07-09 23:51:59 +07:00
|
|
|
*/
|
|
|
|
static const int prio_to_weight[40] = {
|
2007-08-09 16:16:51 +07:00
|
|
|
/* -20 */ 88761, 71755, 56483, 46273, 36291,
|
|
|
|
/* -15 */ 29154, 23254, 18705, 14949, 11916,
|
|
|
|
/* -10 */ 9548, 7620, 6100, 4904, 3906,
|
|
|
|
/* -5 */ 3121, 2501, 1991, 1586, 1277,
|
|
|
|
/* 0 */ 1024, 820, 655, 526, 423,
|
|
|
|
/* 5 */ 335, 272, 215, 172, 137,
|
|
|
|
/* 10 */ 110, 87, 70, 56, 45,
|
|
|
|
/* 15 */ 36, 29, 23, 18, 15,
|
2007-07-09 23:51:59 +07:00
|
|
|
};
|
|
|
|
|
2007-07-16 14:46:31 +07:00
|
|
|
/*
|
|
|
|
* Inverse (2^32/x) values of the prio_to_weight[] array, precalculated.
|
|
|
|
*
|
|
|
|
* In cases where the weight does not change often, we can use the
|
|
|
|
* precalculated inverse to speed up arithmetics by turning divisions
|
|
|
|
* into multiplications:
|
|
|
|
*/
|
2007-07-09 23:51:59 +07:00
|
|
|
static const u32 prio_to_wmult[40] = {
|
2007-08-09 16:16:51 +07:00
|
|
|
/* -20 */ 48388, 59856, 76040, 92818, 118348,
|
|
|
|
/* -15 */ 147320, 184698, 229616, 287308, 360437,
|
|
|
|
/* -10 */ 449829, 563644, 704093, 875809, 1099582,
|
|
|
|
/* -5 */ 1376151, 1717300, 2157191, 2708050, 3363326,
|
|
|
|
/* 0 */ 4194304, 5237765, 6557202, 8165337, 10153587,
|
|
|
|
/* 5 */ 12820798, 15790321, 19976592, 24970740, 31350126,
|
|
|
|
/* 10 */ 39045157, 49367440, 61356676, 76695844, 95443717,
|
|
|
|
/* 15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
|
2007-07-09 23:51:59 +07:00
|
|
|
};
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
|
2009-03-31 11:32:22 +07:00
|
|
|
/* Time spent by the tasks of the cpu accounting group executing in ... */
|
|
|
|
enum cpuacct_stat_index {
|
|
|
|
CPUACCT_STAT_USER, /* ... user mode */
|
|
|
|
CPUACCT_STAT_SYSTEM, /* ... kernel mode */
|
|
|
|
|
|
|
|
CPUACCT_STAT_NSTATS,
|
|
|
|
};
|
|
|
|
|
2007-12-03 02:04:49 +07:00
|
|
|
#ifdef CONFIG_CGROUP_CPUACCT
|
|
|
|
static void cpuacct_charge(struct task_struct *tsk, u64 cputime);
|
2009-03-31 11:32:22 +07:00
|
|
|
static void cpuacct_update_stats(struct task_struct *tsk,
|
|
|
|
enum cpuacct_stat_index idx, cputime_t val);
|
2007-12-03 02:04:49 +07:00
|
|
|
#else
|
|
|
|
static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
|
2009-03-31 11:32:22 +07:00
|
|
|
static inline void cpuacct_update_stats(struct task_struct *tsk,
|
|
|
|
enum cpuacct_stat_index idx, cputime_t val) {}
|
2007-12-03 02:04:49 +07:00
|
|
|
#endif
|
|
|
|
|
2008-04-20 00:45:00 +07:00
|
|
|
static inline void inc_cpu_load(struct rq *rq, unsigned long load)
|
|
|
|
{
|
|
|
|
update_load_add(&rq->load, load);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void dec_cpu_load(struct rq *rq, unsigned long load)
|
|
|
|
{
|
|
|
|
update_load_sub(&rq->load, load);
|
|
|
|
}
|
|
|
|
|
2008-08-19 18:40:47 +07:00
|
|
|
#if (defined(CONFIG_SMP) && defined(CONFIG_FAIR_GROUP_SCHED)) || defined(CONFIG_RT_GROUP_SCHED)
|
2008-08-19 17:33:05 +07:00
|
|
|
typedef int (*tg_visitor)(struct task_group *, void *);
|
2008-06-27 18:41:14 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Iterate the full tree, calling @down when first entering a node and @up when
|
|
|
|
* leaving it for the final time.
|
|
|
|
*/
|
2008-08-19 17:33:05 +07:00
|
|
|
static int walk_tg_tree(tg_visitor down, tg_visitor up, void *data)
|
2008-06-27 18:41:14 +07:00
|
|
|
{
|
|
|
|
struct task_group *parent, *child;
|
2008-08-19 17:33:05 +07:00
|
|
|
int ret;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
parent = &root_task_group;
|
|
|
|
down:
|
2008-08-19 17:33:05 +07:00
|
|
|
ret = (*down)(parent, data);
|
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
2008-06-27 18:41:14 +07:00
|
|
|
list_for_each_entry_rcu(child, &parent->children, siblings) {
|
|
|
|
parent = child;
|
|
|
|
goto down;
|
|
|
|
|
|
|
|
up:
|
|
|
|
continue;
|
|
|
|
}
|
2008-08-19 17:33:05 +07:00
|
|
|
ret = (*up)(parent, data);
|
|
|
|
if (ret)
|
|
|
|
goto out_unlock;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
|
|
|
child = parent;
|
|
|
|
parent = parent->parent;
|
|
|
|
if (parent)
|
|
|
|
goto up;
|
2008-08-19 17:33:05 +07:00
|
|
|
out_unlock:
|
2008-06-27 18:41:14 +07:00
|
|
|
rcu_read_unlock();
|
2008-08-19 17:33:05 +07:00
|
|
|
|
|
|
|
return ret;
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
|
|
|
|
2008-08-19 17:33:05 +07:00
|
|
|
static int tg_nop(struct task_group *tg, void *data)
|
|
|
|
{
|
|
|
|
return 0;
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
2008-08-19 17:33:05 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2009-09-10 18:35:28 +07:00
|
|
|
/* Used instead of source_load when we know the type == 0 */
|
|
|
|
static unsigned long weighted_cpuload(const int cpu)
|
|
|
|
{
|
|
|
|
return cpu_rq(cpu)->load.weight;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a low guess at the load of a migration-source cpu weighted
|
|
|
|
* according to the scheduling class and "nice" value.
|
|
|
|
*
|
|
|
|
* We want to under-estimate the load of migration sources, to
|
|
|
|
* balance conservatively.
|
|
|
|
*/
|
|
|
|
static unsigned long source_load(int cpu, int type)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
unsigned long total = weighted_cpuload(cpu);
|
|
|
|
|
|
|
|
if (type == 0 || !sched_feat(LB_BIAS))
|
|
|
|
return total;
|
|
|
|
|
|
|
|
return min(rq->cpu_load[type-1], total);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a high guess at the load of a migration-target cpu weighted
|
|
|
|
* according to the scheduling class and "nice" value.
|
|
|
|
*/
|
|
|
|
static unsigned long target_load(int cpu, int type)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
unsigned long total = weighted_cpuload(cpu);
|
|
|
|
|
|
|
|
if (type == 0 || !sched_feat(LB_BIAS))
|
|
|
|
return total;
|
|
|
|
|
|
|
|
return max(rq->cpu_load[type-1], total);
|
|
|
|
}
|
|
|
|
|
2009-09-10 19:40:57 +07:00
|
|
|
static unsigned long power_of(int cpu)
|
|
|
|
{
|
2010-05-31 17:37:30 +07:00
|
|
|
return cpu_rq(cpu)->cpu_power;
|
2009-09-10 19:40:57 +07:00
|
|
|
}
|
|
|
|
|
2008-08-19 17:33:05 +07:00
|
|
|
static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
|
|
|
|
|
|
|
|
static unsigned long cpu_avg_load_per_task(int cpu)
|
|
|
|
{
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2008-11-30 02:45:15 +07:00
|
|
|
unsigned long nr_running = ACCESS_ONCE(rq->nr_running);
|
2008-08-19 17:33:05 +07:00
|
|
|
|
2008-11-27 09:04:24 +07:00
|
|
|
if (nr_running)
|
|
|
|
rq->avg_load_per_task = rq->load.weight / nr_running;
|
2008-11-12 17:49:00 +07:00
|
|
|
else
|
|
|
|
rq->avg_load_per_task = 0;
|
2008-08-19 17:33:05 +07:00
|
|
|
|
|
|
|
return rq->avg_load_per_task;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2010-02-02 12:38:57 +07:00
|
|
|
static __read_mostly unsigned long __percpu *update_shares_data;
|
2009-08-27 18:08:56 +07:00
|
|
|
|
2008-06-27 18:41:14 +07:00
|
|
|
static void __set_se_shares(struct sched_entity *se, unsigned long shares);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate and set the cpu's group shares.
|
|
|
|
*/
|
2009-08-27 18:08:56 +07:00
|
|
|
static void update_group_shares_cpu(struct task_group *tg, int cpu,
|
|
|
|
unsigned long sd_shares,
|
|
|
|
unsigned long sd_rq_weight,
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
unsigned long *usd_rq_weight)
|
2008-04-20 00:45:00 +07:00
|
|
|
{
|
2009-08-27 18:08:56 +07:00
|
|
|
unsigned long shares, rq_weight;
|
2009-07-27 19:04:49 +07:00
|
|
|
int boost = 0;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
rq_weight = usd_rq_weight[cpu];
|
2009-07-27 19:04:49 +07:00
|
|
|
if (!rq_weight) {
|
|
|
|
boost = 1;
|
|
|
|
rq_weight = NICE_0_LOAD;
|
|
|
|
}
|
2008-06-27 18:41:23 +07:00
|
|
|
|
2008-06-27 18:41:14 +07:00
|
|
|
/*
|
2009-08-21 18:58:54 +07:00
|
|
|
* \Sum_j shares_j * rq_weight_i
|
|
|
|
* shares_i = -----------------------------
|
|
|
|
* \Sum_j rq_weight_j
|
2008-06-27 18:41:14 +07:00
|
|
|
*/
|
2008-11-19 13:41:57 +07:00
|
|
|
shares = (sd_shares * rq_weight) / sd_rq_weight;
|
2008-10-18 00:27:02 +07:00
|
|
|
shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-10-18 00:27:02 +07:00
|
|
|
if (abs(shares - tg->se[cpu]->load.weight) >
|
|
|
|
sysctl_sched_shares_thresh) {
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
unsigned long flags;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2009-08-27 18:08:56 +07:00
|
|
|
tg->cfs_rq[cpu]->rq_weight = boost ? 0 : rq_weight;
|
2009-07-27 19:04:49 +07:00
|
|
|
tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
|
2008-10-18 00:27:02 +07:00
|
|
|
__set_se_shares(tg->se[cpu], shares);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2008-10-18 00:27:02 +07:00
|
|
|
}
|
2008-04-20 00:45:00 +07:00
|
|
|
}
|
2008-06-27 18:41:14 +07:00
|
|
|
|
|
|
|
/*
|
2008-06-27 18:41:23 +07:00
|
|
|
* Re-compute the task group their per cpu shares over the given domain.
|
|
|
|
* This needs to be done in a bottom-up fashion because the rq weight of a
|
|
|
|
* parent group depends on the shares of its child groups.
|
2008-06-27 18:41:14 +07:00
|
|
|
*/
|
2008-08-19 17:33:05 +07:00
|
|
|
static int tg_shares_up(struct task_group *tg, void *data)
|
2008-06-27 18:41:14 +07:00
|
|
|
{
|
2009-12-04 00:00:07 +07:00
|
|
|
unsigned long weight, rq_weight = 0, sum_weight = 0, shares = 0;
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
unsigned long *usd_rq_weight;
|
2008-08-19 17:33:05 +07:00
|
|
|
struct sched_domain *sd = data;
|
2009-08-27 18:08:56 +07:00
|
|
|
unsigned long flags;
|
2008-06-27 18:41:23 +07:00
|
|
|
int i;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2009-08-27 18:08:56 +07:00
|
|
|
if (!tg->se[0])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
usd_rq_weight = per_cpu_ptr(update_shares_data, smp_processor_id());
|
2009-08-27 18:08:56 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
for_each_cpu(i, sched_domain_span(sd)) {
|
2009-08-27 18:08:56 +07:00
|
|
|
weight = tg->cfs_rq[i]->load.weight;
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
usd_rq_weight[i] = weight;
|
2009-08-27 18:08:56 +07:00
|
|
|
|
2009-12-04 00:00:07 +07:00
|
|
|
rq_weight += weight;
|
2008-11-19 13:41:57 +07:00
|
|
|
/*
|
|
|
|
* If there are currently no tasks on the cpu pretend there
|
|
|
|
* is one of average load so that when a new task gets to
|
|
|
|
* run here it will not get delayed by group starvation.
|
|
|
|
*/
|
|
|
|
if (!weight)
|
|
|
|
weight = NICE_0_LOAD;
|
|
|
|
|
2009-12-04 00:00:07 +07:00
|
|
|
sum_weight += weight;
|
2008-06-27 18:41:23 +07:00
|
|
|
shares += tg->cfs_rq[i]->shares;
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
|
|
|
|
2009-12-04 00:00:07 +07:00
|
|
|
if (!rq_weight)
|
|
|
|
rq_weight = sum_weight;
|
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
if ((!shares && rq_weight) || shares > tg->shares)
|
|
|
|
shares = tg->shares;
|
|
|
|
|
|
|
|
if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
|
|
|
|
shares = tg->shares;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
for_each_cpu(i, sched_domain_span(sd))
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
update_group_shares_cpu(tg, i, shares, rq_weight, usd_rq_weight);
|
2009-08-27 18:08:56 +07:00
|
|
|
|
|
|
|
local_irq_restore(flags);
|
2008-08-19 17:33:05 +07:00
|
|
|
|
|
|
|
return 0;
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-06-27 18:41:23 +07:00
|
|
|
* Compute the cpu's hierarchical load factor for each task group.
|
|
|
|
* This needs to be done in a top-down fashion because the load of a child
|
|
|
|
* group is a fraction of its parents load.
|
2008-06-27 18:41:14 +07:00
|
|
|
*/
|
2008-08-19 17:33:05 +07:00
|
|
|
static int tg_load_down(struct task_group *tg, void *data)
|
2008-06-27 18:41:14 +07:00
|
|
|
{
|
2008-06-27 18:41:23 +07:00
|
|
|
unsigned long load;
|
2008-08-19 17:33:05 +07:00
|
|
|
long cpu = (long)data;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
if (!tg->parent) {
|
|
|
|
load = cpu_rq(cpu)->load.weight;
|
|
|
|
} else {
|
|
|
|
load = tg->parent->cfs_rq[cpu]->h_load;
|
|
|
|
load *= tg->cfs_rq[cpu]->shares;
|
|
|
|
load /= tg->parent->cfs_rq[cpu]->load.weight + 1;
|
|
|
|
}
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
tg->cfs_rq[cpu]->h_load = load;
|
2008-06-27 18:41:14 +07:00
|
|
|
|
2008-08-19 17:33:05 +07:00
|
|
|
return 0;
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
static void update_shares(struct sched_domain *sd)
|
2008-06-27 18:41:19 +07:00
|
|
|
{
|
2009-06-03 20:41:20 +07:00
|
|
|
s64 elapsed;
|
|
|
|
u64 now;
|
|
|
|
|
|
|
|
if (root_task_group_empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
now = cpu_clock(raw_smp_processor_id());
|
|
|
|
elapsed = now - sd->last_update;
|
2008-06-27 18:41:35 +07:00
|
|
|
|
|
|
|
if (elapsed >= (s64)(u64)sysctl_sched_shares_ratelimit) {
|
|
|
|
sd->last_update = now;
|
2008-08-19 17:33:05 +07:00
|
|
|
walk_tg_tree(tg_nop, tg_shares_up, sd);
|
2008-06-27 18:41:35 +07:00
|
|
|
}
|
2008-06-27 18:41:19 +07:00
|
|
|
}
|
|
|
|
|
2008-08-19 17:33:05 +07:00
|
|
|
static void update_h_load(long cpu)
|
2008-06-27 18:41:14 +07:00
|
|
|
{
|
2008-08-19 17:33:05 +07:00
|
|
|
walk_tg_tree(tg_load_down, tg_nop, (void *)cpu);
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2008-06-27 18:41:23 +07:00
|
|
|
static inline void update_shares(struct sched_domain *sd)
|
2008-06-27 18:41:19 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:45:00 +07:00
|
|
|
#endif
|
|
|
|
|
2008-12-29 21:39:51 +07:00
|
|
|
#ifdef CONFIG_PREEMPT
|
|
|
|
|
2009-09-15 19:23:18 +07:00
|
|
|
static void double_rq_lock(struct rq *rq1, struct rq *rq2);
|
|
|
|
|
2008-11-29 02:08:00 +07:00
|
|
|
/*
|
2008-12-29 21:39:51 +07:00
|
|
|
* fair double_lock_balance: Safely acquires both rq->locks in a fair
|
|
|
|
* way at the expense of forcing extra atomic operations in all
|
|
|
|
* invocations. This assures that the double_lock is acquired using the
|
|
|
|
* same underlying policy as the spinlock_t on this architecture, which
|
|
|
|
* reduces latency compared to the unfair variant below. However, it
|
|
|
|
* also adds more overhead and therefore may reduce throughput.
|
2008-11-29 02:08:00 +07:00
|
|
|
*/
|
2008-12-29 21:39:51 +07:00
|
|
|
static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
__releases(this_rq->lock)
|
|
|
|
__acquires(busiest->lock)
|
|
|
|
__acquires(this_rq->lock)
|
|
|
|
{
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&this_rq->lock);
|
2008-12-29 21:39:51 +07:00
|
|
|
double_rq_lock(this_rq, busiest);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
/*
|
|
|
|
* Unfair double_lock_balance: Optimizes throughput at the expense of
|
|
|
|
* latency by eliminating extra atomic operations when the locks are
|
|
|
|
* already in proper order on entry. This favors lower cpu-ids and will
|
|
|
|
* grant the double lock to lower cpus over higher ids under contention,
|
|
|
|
* regardless of entry order into the function.
|
|
|
|
*/
|
|
|
|
static int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
|
2008-11-29 02:08:00 +07:00
|
|
|
__releases(this_rq->lock)
|
|
|
|
__acquires(busiest->lock)
|
|
|
|
__acquires(this_rq->lock)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
if (unlikely(!raw_spin_trylock(&busiest->lock))) {
|
2008-11-29 02:08:00 +07:00
|
|
|
if (busiest < this_rq) {
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&this_rq->lock);
|
|
|
|
raw_spin_lock(&busiest->lock);
|
|
|
|
raw_spin_lock_nested(&this_rq->lock,
|
|
|
|
SINGLE_DEPTH_NESTING);
|
2008-11-29 02:08:00 +07:00
|
|
|
ret = 1;
|
|
|
|
} else
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_nested(&busiest->lock,
|
|
|
|
SINGLE_DEPTH_NESTING);
|
2008-11-29 02:08:00 +07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-29 21:39:51 +07:00
|
|
|
#endif /* CONFIG_PREEMPT */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* double_lock_balance - lock the busiest runqueue, this_rq is locked already.
|
|
|
|
*/
|
|
|
|
static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
{
|
|
|
|
if (unlikely(!irqs_disabled())) {
|
|
|
|
/* printk() doesn't work good under rq->lock */
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&this_rq->lock);
|
2008-12-29 21:39:51 +07:00
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return _double_lock_balance(this_rq, busiest);
|
|
|
|
}
|
|
|
|
|
2008-11-29 02:08:00 +07:00
|
|
|
static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
__releases(busiest->lock)
|
|
|
|
{
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&busiest->lock);
|
2008-11-29 02:08:00 +07:00
|
|
|
lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
|
|
|
|
}
|
2009-12-17 23:00:43 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* double_rq_lock - safely lock two runqueues
|
|
|
|
*
|
|
|
|
* Note this does not disable interrupts like task_rq_lock,
|
|
|
|
* you need to do so manually before calling.
|
|
|
|
*/
|
|
|
|
static void double_rq_lock(struct rq *rq1, struct rq *rq2)
|
|
|
|
__acquires(rq1->lock)
|
|
|
|
__acquires(rq2->lock)
|
|
|
|
{
|
|
|
|
BUG_ON(!irqs_disabled());
|
|
|
|
if (rq1 == rq2) {
|
|
|
|
raw_spin_lock(&rq1->lock);
|
|
|
|
__acquire(rq2->lock); /* Fake it out ;) */
|
|
|
|
} else {
|
|
|
|
if (rq1 < rq2) {
|
|
|
|
raw_spin_lock(&rq1->lock);
|
|
|
|
raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
|
|
|
|
} else {
|
|
|
|
raw_spin_lock(&rq2->lock);
|
|
|
|
raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* double_rq_unlock - safely unlock two runqueues
|
|
|
|
*
|
|
|
|
* Note this does not restore interrupts like task_rq_unlock,
|
|
|
|
* you need to do so manually after calling.
|
|
|
|
*/
|
|
|
|
static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
|
|
|
|
__releases(rq1->lock)
|
|
|
|
__releases(rq2->lock)
|
|
|
|
{
|
|
|
|
raw_spin_unlock(&rq1->lock);
|
|
|
|
if (rq1 != rq2)
|
|
|
|
raw_spin_unlock(&rq2->lock);
|
|
|
|
else
|
|
|
|
__release(rq2->lock);
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:45:00 +07:00
|
|
|
#endif
|
|
|
|
|
2008-06-28 02:35:50 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2008-06-27 20:42:36 +07:00
|
|
|
static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares)
|
|
|
|
{
|
2008-06-28 02:35:50 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2008-06-27 20:42:36 +07:00
|
|
|
cfs_rq->shares = shares;
|
|
|
|
#endif
|
|
|
|
}
|
2008-06-28 02:35:50 +07:00
|
|
|
#endif
|
2008-01-26 03:08:09 +07:00
|
|
|
|
2010-04-23 02:50:19 +07:00
|
|
|
static void calc_load_account_idle(struct rq *this_rq);
|
2009-11-30 18:16:46 +07:00
|
|
|
static void update_sysctl(void);
|
2009-11-30 18:16:48 +07:00
|
|
|
static int get_update_sysctl_factor(void);
|
2009-04-11 15:43:41 +07:00
|
|
|
|
2009-11-27 23:32:46 +07:00
|
|
|
static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
|
|
|
|
{
|
|
|
|
set_task_rq(p, cpu);
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
|
|
|
|
* successfuly executed on another CPU. We must ensure that updates of
|
|
|
|
* per-task data have been completed by this moment.
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
|
|
|
task_thread_info(p)->cpu = cpu;
|
|
|
|
#endif
|
|
|
|
}
|
2009-04-11 15:43:41 +07:00
|
|
|
|
2009-12-17 23:00:43 +07:00
|
|
|
static const struct sched_class rt_sched_class;
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
#define sched_class_highest (&rt_sched_class)
|
2008-06-05 02:04:05 +07:00
|
|
|
#define for_each_class(class) \
|
|
|
|
for (class = sched_class_highest; class; class = class->next)
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2009-12-17 23:00:43 +07:00
|
|
|
#include "sched_stats.h"
|
|
|
|
|
2008-06-27 18:41:14 +07:00
|
|
|
static void inc_nr_running(struct rq *rq)
|
2007-08-02 22:41:40 +07:00
|
|
|
{
|
|
|
|
rq->nr_running++;
|
|
|
|
}
|
|
|
|
|
2008-06-27 18:41:14 +07:00
|
|
|
static void dec_nr_running(struct rq *rq)
|
2007-08-02 22:41:40 +07:00
|
|
|
{
|
|
|
|
rq->nr_running--;
|
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
static void set_load_weight(struct task_struct *p)
|
|
|
|
{
|
|
|
|
if (task_has_rt_policy(p)) {
|
2010-05-31 17:37:30 +07:00
|
|
|
p->se.load.weight = 0;
|
|
|
|
p->se.load.inv_weight = WMULT_CONST;
|
2007-07-09 23:51:59 +07:00
|
|
|
return;
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* SCHED_IDLE tasks get minimal weight:
|
|
|
|
*/
|
|
|
|
if (p->policy == SCHED_IDLE) {
|
|
|
|
p->se.load.weight = WEIGHT_IDLEPRIO;
|
|
|
|
p->se.load.inv_weight = WMULT_IDLEPRIO;
|
|
|
|
return;
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
p->se.load.weight = prio_to_weight[p->static_prio - MAX_RT_PRIO];
|
|
|
|
p->se.load.inv_weight = prio_to_wmult[p->static_prio - MAX_RT_PRIO];
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2010-03-24 22:38:48 +07:00
|
|
|
static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
|
2008-06-28 03:30:00 +07:00
|
|
|
{
|
2010-03-11 23:16:20 +07:00
|
|
|
update_rq_clock(rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
sched_info_queued(p);
|
2010-03-24 22:38:48 +07:00
|
|
|
p->sched_class->enqueue_task(rq, p, flags);
|
2007-07-09 23:51:59 +07:00
|
|
|
p->se.on_rq = 1;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2010-03-24 22:38:48 +07:00
|
|
|
static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
2010-03-11 23:16:20 +07:00
|
|
|
update_rq_clock(rq);
|
sched: fix accounting in task delay accounting & migration
On Thu, Jun 19, 2008 at 12:27:14PM +0200, Peter Zijlstra wrote:
> On Thu, 2008-06-05 at 10:50 +0530, Ankita Garg wrote:
>
> > Thanks Peter for the explanation...
> >
> > I agree with the above and that is the reason why I did not see weird
> > values with cpu_time. But, run_delay still would suffer skews as the end
> > points for delta could be taken on different cpus due to migration (more
> > so on RT kernel due to the push-pull operations). With the below patch,
> > I could not reproduce the issue I had seen earlier. After every dequeue,
> > we take the delta and start wait measurements from zero when moved to a
> > different rq.
>
> OK, so task delay delay accounting is broken because it doesn't take
> migration into account.
>
> What you've done is make it symmetric wrt enqueue, and account it like
>
> cpu0 cpu1
>
> enqueue
> <wait-d1>
> dequeue
> enqueue
> <wait-d2>
> run
>
> Where you add both d1 and d2 to the run_delay,.. right?
>
Thanks for reviewing the patch. The above is exactly what I have done.
> This seems like a good fix, however it looks like the patch will break
> compilation in !CONFIG_SCHEDSTATS && !CONFIG_TASK_DELAY_ACCT, of it
> failing to provide a stub for sched_info_dequeue() in that case.
Fixed. Pl. find the new patch below.
Signed-off-by: Ankita Garg <ankita@in.ibm.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Gregory Haskins <ghaskins@novell.com>
Cc: rostedt@goodmis.org
Cc: suresh.b.siddha@intel.com
Cc: aneesh.kumar@linux.vnet.ibm.com
Cc: dhaval@linux.vnet.ibm.com
Cc: vatsa@linux.vnet.ibm.com
Cc: David Bahi <DBahi@novell.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-01 16:00:06 +07:00
|
|
|
sched_info_dequeued(p);
|
2010-03-24 22:38:48 +07:00
|
|
|
p->sched_class->dequeue_task(rq, p, flags);
|
2007-07-09 23:51:59 +07:00
|
|
|
p->se.on_rq = 0;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2009-12-17 23:00:43 +07:00
|
|
|
/*
|
|
|
|
* activate_task - move a task to the runqueue.
|
|
|
|
*/
|
2010-03-24 22:38:48 +07:00
|
|
|
static void activate_task(struct rq *rq, struct task_struct *p, int flags)
|
2009-12-17 23:00:43 +07:00
|
|
|
{
|
|
|
|
if (task_contributes_to_load(p))
|
|
|
|
rq->nr_uninterruptible--;
|
|
|
|
|
2010-03-24 22:38:48 +07:00
|
|
|
enqueue_task(rq, p, flags);
|
2009-12-17 23:00:43 +07:00
|
|
|
inc_nr_running(rq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* deactivate_task - remove a task from the runqueue.
|
|
|
|
*/
|
2010-03-24 22:38:48 +07:00
|
|
|
static void deactivate_task(struct rq *rq, struct task_struct *p, int flags)
|
2009-12-17 23:00:43 +07:00
|
|
|
{
|
|
|
|
if (task_contributes_to_load(p))
|
|
|
|
rq->nr_uninterruptible++;
|
|
|
|
|
2010-03-24 22:38:48 +07:00
|
|
|
dequeue_task(rq, p, flags);
|
2009-12-17 23:00:43 +07:00
|
|
|
dec_nr_running(rq);
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "sched_idletask.c"
|
|
|
|
#include "sched_fair.c"
|
|
|
|
#include "sched_rt.c"
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
# include "sched_debug.c"
|
|
|
|
#endif
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
2007-07-09 23:51:59 +07:00
|
|
|
* __normal_prio - return the priority that is based on the static prio
|
2007-07-09 23:51:59 +07:00
|
|
|
*/
|
|
|
|
static inline int __normal_prio(struct task_struct *p)
|
|
|
|
{
|
2007-07-09 23:51:59 +07:00
|
|
|
return p->static_prio;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 16:54:51 +07:00
|
|
|
/*
|
|
|
|
* Calculate the expected normal priority: i.e. priority
|
|
|
|
* without taking RT-inheritance into account. Might be
|
|
|
|
* boosted by interactivity modifiers. Changes upon fork,
|
|
|
|
* setprio syscalls, and whenever the interactivity
|
|
|
|
* estimator recalculates.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
static inline int normal_prio(struct task_struct *p)
|
2006-06-27 16:54:51 +07:00
|
|
|
{
|
|
|
|
int prio;
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
if (task_has_rt_policy(p))
|
2006-06-27 16:54:51 +07:00
|
|
|
prio = MAX_RT_PRIO-1 - p->rt_priority;
|
|
|
|
else
|
|
|
|
prio = __normal_prio(p);
|
|
|
|
return prio;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the current priority, i.e. the priority
|
|
|
|
* taken into account by the scheduler. This value might
|
|
|
|
* be boosted by RT tasks, or might be boosted by
|
|
|
|
* interactivity modifiers. Will be RT if the task got
|
|
|
|
* RT-boosted. If not then it returns p->normal_prio.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
static int effective_prio(struct task_struct *p)
|
2006-06-27 16:54:51 +07:00
|
|
|
{
|
|
|
|
p->normal_prio = normal_prio(p);
|
|
|
|
/*
|
|
|
|
* If we are RT tasks or we were boosted to RT priority,
|
|
|
|
* keep the priority unchanged. Otherwise, update priority
|
|
|
|
* to the normal priority:
|
|
|
|
*/
|
|
|
|
if (!rt_prio(p->prio))
|
|
|
|
return p->normal_prio;
|
|
|
|
return p->prio;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* task_curr - is this task currently executing on a CPU?
|
|
|
|
* @p: the task in question.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
inline int task_curr(const struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return cpu_curr(task_cpu(p)) == p;
|
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:22 +07:00
|
|
|
static inline void check_class_changed(struct rq *rq, struct task_struct *p,
|
|
|
|
const struct sched_class *prev_class,
|
|
|
|
int oldprio, int running)
|
|
|
|
{
|
|
|
|
if (prev_class != p->sched_class) {
|
|
|
|
if (prev_class->switched_from)
|
|
|
|
prev_class->switched_from(rq, p, running);
|
|
|
|
p->sched_class->switched_to(rq, p, running);
|
|
|
|
} else
|
|
|
|
p->sched_class->prio_changed(rq, p, oldprio, running);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2007-10-15 22:00:18 +07:00
|
|
|
/*
|
|
|
|
* Is this task likely cache-hot:
|
|
|
|
*/
|
2008-01-26 03:08:09 +07:00
|
|
|
static int
|
2007-10-15 22:00:18 +07:00
|
|
|
task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
|
|
|
|
{
|
|
|
|
s64 delta;
|
|
|
|
|
2009-12-17 00:04:33 +07:00
|
|
|
if (p->sched_class != &fair_sched_class)
|
|
|
|
return 0;
|
|
|
|
|
2008-03-15 23:10:34 +07:00
|
|
|
/*
|
|
|
|
* Buddy candidates are cache hot:
|
|
|
|
*/
|
sched: Strengthen buddies and mitigate buddy induced latencies
This patch restores the effectiveness of LAST_BUDDY in preventing
pgsql+oltp from collapsing due to wakeup preemption. It also
switches LAST_BUDDY to exclusively do what it does best, namely
mitigate the effects of aggressive wakeup preemption, which
improves vmark throughput markedly, and restores mysql+oltp
scalability.
Since buddies are about scalability, enable them beginning at the
point where we begin expanding sched_latency, namely
sched_nr_latency. Previously, buddies were cleared aggressively,
which seriously reduced their effectiveness. Not clearing
aggressively however, produces a small drop in mysql+oltp
throughput immediately after peak, indicating that LAST_BUDDY is
actually doing some harm. This is right at the point where X on the
desktop in competition with another load wants low latency service.
Ergo, do not enable until we need to scale.
To mitigate latency induced by buddies, or by a task just missing
wakeup preemption, check latency at tick time.
Last hunk prevents buddies from stymieing BALANCE_NEWIDLE via
CACHE_HOT_BUDDY.
Supporting performance tests:
tip = v2.6.32-rc5-1497-ga525b32
tipx = NO_GENTLE_FAIR_SLEEPERS NEXT_BUDDY granularity knobs = 31 knobs + 31 buddies
tip+x = NO_GENTLE_FAIR_SLEEPERS granularity knobs = 31 knobs
(Three run averages except where noted.)
vmark:
------
tip 108466 messages per second
tip+ 125307 messages per second
tip+x 125335 messages per second
tipx 117781 messages per second
2.6.31.3 122729 messages per second
mysql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 9949.89 18690.20 34801.24 34460.04 32682.88 30765.97 28305.27 25059.64 19548.08
tip+ 10013.90 18526.84 34900.38 34420.14 33069.83 32083.40 30578.30 28010.71 25605.47
tipx 9698.71 18002.70 34477.56 33420.01 32634.30 31657.27 29932.67 26827.52 21487.18
2.6.31.3 8243.11 18784.20 34404.83 33148.38 31900.32 31161.90 29663.81 25995.94 18058.86
pgsql+oltp:
-----------
clients 1 2 4 8 16 32 64 128 256
..........................................................................................
tip 13686.37 26609.25 51934.28 51347.81 49479.51 45312.65 36691.91 26851.57 24145.35
tip+ (1x) 13907.85 27135.87 52951.98 52514.04 51742.52 50705.43 49947.97 48374.19 46227.94
tip+x 13906.78 27065.81 52951.19 52542.59 52176.11 51815.94 50838.90 49439.46 46891.00
tipx 13742.46 26769.81 52351.99 51891.73 51320.79 50938.98 50248.65 48908.70 46553.84
2.6.31.3 13815.35 26906.46 52683.34 52061.31 51937.10 51376.80 50474.28 49394.47 47003.25
Signed-off-by: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-10-24 04:09:22 +07:00
|
|
|
if (sched_feat(CACHE_HOT_BUDDY) && this_rq()->nr_running &&
|
sched: backward looking buddy
Impact: improve/change/fix wakeup-buddy scheduling
Currently we only have a forward looking buddy, that is, we prefer to
schedule to the task we last woke up, under the presumption that its
going to consume the data we just produced, and therefore will have
cache hot benefits.
This allows co-waking producer/consumer task pairs to run ahead of the
pack for a little while, keeping their cache warm. Without this, we
would interleave all pairs, utterly trashing the cache.
This patch introduces a backward looking buddy, that is, suppose that
in the above scenario, the consumer preempts the producer before it
can go to sleep, we will therefore miss the wakeup from consumer to
producer (its already running, after all), breaking the cycle and
reverting to the cache-trashing interleaved schedule pattern.
The backward buddy will try to schedule back to the task that woke us
up in case the forward buddy is not available, under the assumption
that the last task will be the one with the most cache hot task around
barring current.
This will basically allow a task to continue after it got preempted.
In order to avoid starvation, we allow either buddy to get wakeup_gran
ahead of the pack.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Mike Galbraith <efault@gmx.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-11-05 03:25:09 +07:00
|
|
|
(&p->se == cfs_rq_of(&p->se)->next ||
|
|
|
|
&p->se == cfs_rq_of(&p->se)->last))
|
2008-03-15 23:10:34 +07:00
|
|
|
return 1;
|
|
|
|
|
2007-10-15 22:00:18 +07:00
|
|
|
if (sysctl_sched_migration_cost == -1)
|
|
|
|
return 1;
|
|
|
|
if (sysctl_sched_migration_cost == 0)
|
|
|
|
return 0;
|
|
|
|
|
2007-10-15 22:00:18 +07:00
|
|
|
delta = now - p->se.exec_start;
|
|
|
|
|
|
|
|
return delta < (s64)sysctl_sched_migration_cost;
|
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
|
2007-07-09 23:51:58 +07:00
|
|
|
{
|
2009-12-17 00:04:36 +07:00
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
/*
|
|
|
|
* We should never call set_task_cpu() on a blocked task,
|
|
|
|
* ttwu() will sort out the placement.
|
|
|
|
*/
|
2009-12-17 19:16:31 +07:00
|
|
|
WARN_ON_ONCE(p->state != TASK_RUNNING && p->state != TASK_WAKING &&
|
|
|
|
!(task_thread_info(p)->preempt_count & PREEMPT_ACTIVE));
|
2009-12-17 00:04:36 +07:00
|
|
|
#endif
|
|
|
|
|
2009-05-05 15:49:59 +07:00
|
|
|
trace_sched_migrate_task(p, new_cpu);
|
2008-12-10 14:08:22 +07:00
|
|
|
|
2009-12-22 21:43:19 +07:00
|
|
|
if (task_cpu(p) != new_cpu) {
|
|
|
|
p->se.nr_migrations++;
|
|
|
|
perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, 1, NULL, 0);
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
__set_task_cpu(p, new_cpu);
|
2007-07-09 23:51:58 +07:00
|
|
|
}
|
|
|
|
|
2010-05-06 23:49:21 +07:00
|
|
|
struct migration_arg {
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *task;
|
2005-04-17 05:20:36 +07:00
|
|
|
int dest_cpu;
|
2006-07-03 14:25:42 +07:00
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-05-06 23:49:21 +07:00
|
|
|
static int migration_cpu_stop(void *data);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* The task's runqueue lock must be held.
|
|
|
|
* Returns true if you have to wait for migration thread.
|
|
|
|
*/
|
2010-05-06 23:49:21 +07:00
|
|
|
static bool migrate_task(struct task_struct *p, int dest_cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = task_rq(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the task is not on a runqueue (and not running), then
|
2009-12-17 00:04:36 +07:00
|
|
|
* the next wake-up will properly place the task.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2010-05-06 23:49:21 +07:00
|
|
|
return p->se.on_rq || task_running(rq, p);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* wait_task_inactive - wait for a thread to unschedule.
|
|
|
|
*
|
2008-07-26 09:45:58 +07:00
|
|
|
* If @match_state is nonzero, it's the @p->state value just checked and
|
|
|
|
* not expected to change. If it changes, i.e. @p might have woken up,
|
|
|
|
* then return zero. When we succeed in waiting for @p to be off its CPU,
|
|
|
|
* we return a positive number (its total switch count). If a second call
|
|
|
|
* a short while later returns the same number, the caller can be sure that
|
|
|
|
* @p has remained unscheduled the whole time.
|
|
|
|
*
|
2005-04-17 05:20:36 +07:00
|
|
|
* The caller must ensure that the task *will* unschedule sometime soon,
|
|
|
|
* else this function might spin for a *long* time. This function can't
|
|
|
|
* be called with interrupts off, or it may introduce deadlock with
|
|
|
|
* smp_call_function() if an IPI is sent by the same process we are
|
|
|
|
* waiting to become inactive.
|
|
|
|
*/
|
2008-07-26 09:45:58 +07:00
|
|
|
unsigned long wait_task_inactive(struct task_struct *p, long match_state)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-07-09 23:51:59 +07:00
|
|
|
int running, on_rq;
|
2008-07-26 09:45:58 +07:00
|
|
|
unsigned long ncsw;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
for (;;) {
|
|
|
|
/*
|
|
|
|
* We do the initial early heuristics without holding
|
|
|
|
* any task-queue locks at all. We'll only try to get
|
|
|
|
* the runqueue lock when things look like they will
|
|
|
|
* work out!
|
|
|
|
*/
|
|
|
|
rq = task_rq(p);
|
Fix possible runqueue lock starvation in wait_task_inactive()
Miklos Szeredi reported very long pauses (several seconds, sometimes
more) on his T60 (with a Core2Duo) which he managed to track down to
wait_task_inactive()'s open-coded busy-loop.
He observed that an interrupt on one core tries to acquire the
runqueue-lock but does not succeed in doing so for a very long time -
while wait_task_inactive() on the other core loops waiting for the first
core to deschedule a task (which it wont do while spinning in an
interrupt handler).
This rewrites wait_task_inactive() to do all its waiting optimistically
without any locks taken at all, and then just double-check the end
result with the proper runqueue lock held over just a very short
section. If there were races in the optimistic wait, of a preemption
event scheduled the process away, we simply re-synchronize, and start
over.
So the code now looks like this:
repeat:
/* Unlocked, optimistic looping! */
rq = task_rq(p);
while (task_running(rq, p))
cpu_relax();
/* Get the *real* values */
rq = task_rq_lock(p, &flags);
running = task_running(rq, p);
array = p->array;
task_rq_unlock(rq, &flags);
/* Check them.. */
if (unlikely(running)) {
cpu_relax();
goto repeat;
}
/* Preempted away? Yield if so.. */
if (unlikely(array)) {
yield();
goto repeat;
}
Basically, that first "while()" loop is done entirely without any
locking at all (and doesn't check for the case where the target process
might have been preempted away), and so it's possibly "incorrect", but
we don't really care. Both the runqueue used, and the "task_running()"
check might be the wrong tests, but they won't oops - they just mean
that we could possibly get the wrong results due to lack of locking and
exit the loop early in the case of a race condition.
So once we've exited the loop, we then get the proper (and careful) rq
lock, and check the running/runnable state _safely_. And if it turns
out that our quick-and-dirty and unsafe loop was wrong after all, we
just go back and try it all again.
(The patch also adds a lot of comments, which is the actual bulk of it
all, to make it more obvious why we can do these things without holding
the locks).
Thanks to Miklos for all the testing and tracking it down.
Tested-by: Miklos Szeredi <miklos@szeredi.hu>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-18 23:34:40 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* If the task is actively running on another CPU
|
|
|
|
* still, just relax and busy-wait without holding
|
|
|
|
* any locks.
|
|
|
|
*
|
|
|
|
* NOTE! Since we don't hold any locks, it's not
|
|
|
|
* even sure that "rq" stays as the right runqueue!
|
|
|
|
* But we don't care, since "task_running()" will
|
|
|
|
* return false if the runqueue has changed and p
|
|
|
|
* is actually now running somewhere else!
|
|
|
|
*/
|
2008-07-26 09:45:58 +07:00
|
|
|
while (task_running(rq, p)) {
|
|
|
|
if (match_state && unlikely(p->state != match_state))
|
|
|
|
return 0;
|
2007-10-15 22:00:14 +07:00
|
|
|
cpu_relax();
|
2008-07-26 09:45:58 +07:00
|
|
|
}
|
Fix possible runqueue lock starvation in wait_task_inactive()
Miklos Szeredi reported very long pauses (several seconds, sometimes
more) on his T60 (with a Core2Duo) which he managed to track down to
wait_task_inactive()'s open-coded busy-loop.
He observed that an interrupt on one core tries to acquire the
runqueue-lock but does not succeed in doing so for a very long time -
while wait_task_inactive() on the other core loops waiting for the first
core to deschedule a task (which it wont do while spinning in an
interrupt handler).
This rewrites wait_task_inactive() to do all its waiting optimistically
without any locks taken at all, and then just double-check the end
result with the proper runqueue lock held over just a very short
section. If there were races in the optimistic wait, of a preemption
event scheduled the process away, we simply re-synchronize, and start
over.
So the code now looks like this:
repeat:
/* Unlocked, optimistic looping! */
rq = task_rq(p);
while (task_running(rq, p))
cpu_relax();
/* Get the *real* values */
rq = task_rq_lock(p, &flags);
running = task_running(rq, p);
array = p->array;
task_rq_unlock(rq, &flags);
/* Check them.. */
if (unlikely(running)) {
cpu_relax();
goto repeat;
}
/* Preempted away? Yield if so.. */
if (unlikely(array)) {
yield();
goto repeat;
}
Basically, that first "while()" loop is done entirely without any
locking at all (and doesn't check for the case where the target process
might have been preempted away), and so it's possibly "incorrect", but
we don't really care. Both the runqueue used, and the "task_running()"
check might be the wrong tests, but they won't oops - they just mean
that we could possibly get the wrong results due to lack of locking and
exit the loop early in the case of a race condition.
So once we've exited the loop, we then get the proper (and careful) rq
lock, and check the running/runnable state _safely_. And if it turns
out that our quick-and-dirty and unsafe loop was wrong after all, we
just go back and try it all again.
(The patch also adds a lot of comments, which is the actual bulk of it
all, to make it more obvious why we can do these things without holding
the locks).
Thanks to Miklos for all the testing and tracking it down.
Tested-by: Miklos Szeredi <miklos@szeredi.hu>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-18 23:34:40 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* Ok, time to look more closely! We need the rq
|
|
|
|
* lock now, to be *sure*. If we're wrong, we'll
|
|
|
|
* just go back and repeat.
|
|
|
|
*/
|
|
|
|
rq = task_rq_lock(p, &flags);
|
2010-05-05 01:36:56 +07:00
|
|
|
trace_sched_wait_task(p);
|
2007-10-15 22:00:14 +07:00
|
|
|
running = task_running(rq, p);
|
|
|
|
on_rq = p->se.on_rq;
|
2008-07-26 09:45:58 +07:00
|
|
|
ncsw = 0;
|
2008-08-21 06:54:44 +07:00
|
|
|
if (!match_state || p->state == match_state)
|
2008-08-21 06:54:44 +07:00
|
|
|
ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
|
2007-10-15 22:00:14 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
Fix possible runqueue lock starvation in wait_task_inactive()
Miklos Szeredi reported very long pauses (several seconds, sometimes
more) on his T60 (with a Core2Duo) which he managed to track down to
wait_task_inactive()'s open-coded busy-loop.
He observed that an interrupt on one core tries to acquire the
runqueue-lock but does not succeed in doing so for a very long time -
while wait_task_inactive() on the other core loops waiting for the first
core to deschedule a task (which it wont do while spinning in an
interrupt handler).
This rewrites wait_task_inactive() to do all its waiting optimistically
without any locks taken at all, and then just double-check the end
result with the proper runqueue lock held over just a very short
section. If there were races in the optimistic wait, of a preemption
event scheduled the process away, we simply re-synchronize, and start
over.
So the code now looks like this:
repeat:
/* Unlocked, optimistic looping! */
rq = task_rq(p);
while (task_running(rq, p))
cpu_relax();
/* Get the *real* values */
rq = task_rq_lock(p, &flags);
running = task_running(rq, p);
array = p->array;
task_rq_unlock(rq, &flags);
/* Check them.. */
if (unlikely(running)) {
cpu_relax();
goto repeat;
}
/* Preempted away? Yield if so.. */
if (unlikely(array)) {
yield();
goto repeat;
}
Basically, that first "while()" loop is done entirely without any
locking at all (and doesn't check for the case where the target process
might have been preempted away), and so it's possibly "incorrect", but
we don't really care. Both the runqueue used, and the "task_running()"
check might be the wrong tests, but they won't oops - they just mean
that we could possibly get the wrong results due to lack of locking and
exit the loop early in the case of a race condition.
So once we've exited the loop, we then get the proper (and careful) rq
lock, and check the running/runnable state _safely_. And if it turns
out that our quick-and-dirty and unsafe loop was wrong after all, we
just go back and try it all again.
(The patch also adds a lot of comments, which is the actual bulk of it
all, to make it more obvious why we can do these things without holding
the locks).
Thanks to Miklos for all the testing and tracking it down.
Tested-by: Miklos Szeredi <miklos@szeredi.hu>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-18 23:34:40 +07:00
|
|
|
|
2008-07-26 09:45:58 +07:00
|
|
|
/*
|
|
|
|
* If it changed from the expected state, bail out now.
|
|
|
|
*/
|
|
|
|
if (unlikely(!ncsw))
|
|
|
|
break;
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* Was it really running after all now that we
|
|
|
|
* checked with the proper locks actually held?
|
|
|
|
*
|
|
|
|
* Oops. Go back and try again..
|
|
|
|
*/
|
|
|
|
if (unlikely(running)) {
|
|
|
|
cpu_relax();
|
|
|
|
continue;
|
|
|
|
}
|
Fix possible runqueue lock starvation in wait_task_inactive()
Miklos Szeredi reported very long pauses (several seconds, sometimes
more) on his T60 (with a Core2Duo) which he managed to track down to
wait_task_inactive()'s open-coded busy-loop.
He observed that an interrupt on one core tries to acquire the
runqueue-lock but does not succeed in doing so for a very long time -
while wait_task_inactive() on the other core loops waiting for the first
core to deschedule a task (which it wont do while spinning in an
interrupt handler).
This rewrites wait_task_inactive() to do all its waiting optimistically
without any locks taken at all, and then just double-check the end
result with the proper runqueue lock held over just a very short
section. If there were races in the optimistic wait, of a preemption
event scheduled the process away, we simply re-synchronize, and start
over.
So the code now looks like this:
repeat:
/* Unlocked, optimistic looping! */
rq = task_rq(p);
while (task_running(rq, p))
cpu_relax();
/* Get the *real* values */
rq = task_rq_lock(p, &flags);
running = task_running(rq, p);
array = p->array;
task_rq_unlock(rq, &flags);
/* Check them.. */
if (unlikely(running)) {
cpu_relax();
goto repeat;
}
/* Preempted away? Yield if so.. */
if (unlikely(array)) {
yield();
goto repeat;
}
Basically, that first "while()" loop is done entirely without any
locking at all (and doesn't check for the case where the target process
might have been preempted away), and so it's possibly "incorrect", but
we don't really care. Both the runqueue used, and the "task_running()"
check might be the wrong tests, but they won't oops - they just mean
that we could possibly get the wrong results due to lack of locking and
exit the loop early in the case of a race condition.
So once we've exited the loop, we then get the proper (and careful) rq
lock, and check the running/runnable state _safely_. And if it turns
out that our quick-and-dirty and unsafe loop was wrong after all, we
just go back and try it all again.
(The patch also adds a lot of comments, which is the actual bulk of it
all, to make it more obvious why we can do these things without holding
the locks).
Thanks to Miklos for all the testing and tracking it down.
Tested-by: Miklos Szeredi <miklos@szeredi.hu>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-18 23:34:40 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* It's not enough that it's not actively running,
|
|
|
|
* it must be off the runqueue _entirely_, and not
|
|
|
|
* preempted!
|
|
|
|
*
|
2009-03-17 02:58:09 +07:00
|
|
|
* So if it was still runnable (but just not actively
|
2007-10-15 22:00:14 +07:00
|
|
|
* running right now), it's preempted, and we should
|
|
|
|
* yield - it could be a while.
|
|
|
|
*/
|
|
|
|
if (unlikely(on_rq)) {
|
|
|
|
schedule_timeout_uninterruptible(1);
|
|
|
|
continue;
|
|
|
|
}
|
Fix possible runqueue lock starvation in wait_task_inactive()
Miklos Szeredi reported very long pauses (several seconds, sometimes
more) on his T60 (with a Core2Duo) which he managed to track down to
wait_task_inactive()'s open-coded busy-loop.
He observed that an interrupt on one core tries to acquire the
runqueue-lock but does not succeed in doing so for a very long time -
while wait_task_inactive() on the other core loops waiting for the first
core to deschedule a task (which it wont do while spinning in an
interrupt handler).
This rewrites wait_task_inactive() to do all its waiting optimistically
without any locks taken at all, and then just double-check the end
result with the proper runqueue lock held over just a very short
section. If there were races in the optimistic wait, of a preemption
event scheduled the process away, we simply re-synchronize, and start
over.
So the code now looks like this:
repeat:
/* Unlocked, optimistic looping! */
rq = task_rq(p);
while (task_running(rq, p))
cpu_relax();
/* Get the *real* values */
rq = task_rq_lock(p, &flags);
running = task_running(rq, p);
array = p->array;
task_rq_unlock(rq, &flags);
/* Check them.. */
if (unlikely(running)) {
cpu_relax();
goto repeat;
}
/* Preempted away? Yield if so.. */
if (unlikely(array)) {
yield();
goto repeat;
}
Basically, that first "while()" loop is done entirely without any
locking at all (and doesn't check for the case where the target process
might have been preempted away), and so it's possibly "incorrect", but
we don't really care. Both the runqueue used, and the "task_running()"
check might be the wrong tests, but they won't oops - they just mean
that we could possibly get the wrong results due to lack of locking and
exit the loop early in the case of a race condition.
So once we've exited the loop, we then get the proper (and careful) rq
lock, and check the running/runnable state _safely_. And if it turns
out that our quick-and-dirty and unsafe loop was wrong after all, we
just go back and try it all again.
(The patch also adds a lot of comments, which is the actual bulk of it
all, to make it more obvious why we can do these things without holding
the locks).
Thanks to Miklos for all the testing and tracking it down.
Tested-by: Miklos Szeredi <miklos@szeredi.hu>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-06-18 23:34:40 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* Ahh, all good. It wasn't running, and it wasn't
|
|
|
|
* runnable, which means that it will never become
|
|
|
|
* running in the future either. We're all done!
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
2008-07-26 09:45:58 +07:00
|
|
|
|
|
|
|
return ncsw;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/***
|
|
|
|
* kick_process - kick a running thread to enter/exit the kernel
|
|
|
|
* @p: the to-be-kicked thread
|
|
|
|
*
|
|
|
|
* Cause a process which is running on another CPU to enter
|
|
|
|
* kernel-mode, without any delay. (to get signals handled.)
|
|
|
|
*
|
|
|
|
* NOTE: this function doesnt have to take the runqueue lock,
|
|
|
|
* because all it wants to ensure is that the remote task enters
|
|
|
|
* the kernel. If the IPI races and the task has been migrated
|
|
|
|
* to another CPU then no harm is done and the purpose has been
|
|
|
|
* achieved as well.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
void kick_process(struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
cpu = task_cpu(p);
|
|
|
|
if ((cpu != smp_processor_id()) && task_curr(p))
|
|
|
|
smp_send_reschedule(cpu);
|
|
|
|
preempt_enable();
|
|
|
|
}
|
2009-06-13 11:27:00 +07:00
|
|
|
EXPORT_SYMBOL_GPL(kick_process);
|
2005-06-26 04:57:29 +07:00
|
|
|
#endif /* CONFIG_SMP */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-12-05 02:12:29 +07:00
|
|
|
/**
|
|
|
|
* task_oncpu_function_call - call a function on the cpu on which a task runs
|
|
|
|
* @p: the task to evaluate
|
|
|
|
* @func: the function to be called
|
|
|
|
* @info: the function call argument
|
|
|
|
*
|
|
|
|
* Calls the function @func when the task is currently running. This might
|
|
|
|
* be on the current CPU, which just calls the function directly
|
|
|
|
*/
|
|
|
|
void task_oncpu_function_call(struct task_struct *p,
|
|
|
|
void (*func) (void *info), void *info)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
cpu = task_cpu(p);
|
|
|
|
if (task_curr(p))
|
|
|
|
smp_call_function_single(cpu, func, info, 1);
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
2009-11-25 19:31:39 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2010-03-15 16:10:19 +07:00
|
|
|
/*
|
|
|
|
* ->cpus_allowed is protected by either TASK_WAKING or rq->lock held.
|
|
|
|
*/
|
2009-12-17 00:04:38 +07:00
|
|
|
static int select_fallback_rq(int cpu, struct task_struct *p)
|
|
|
|
{
|
|
|
|
int dest_cpu;
|
|
|
|
const struct cpumask *nodemask = cpumask_of_node(cpu_to_node(cpu));
|
|
|
|
|
|
|
|
/* Look for allowed, online CPU in same node. */
|
|
|
|
for_each_cpu_and(dest_cpu, nodemask, cpu_active_mask)
|
|
|
|
if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
|
|
|
|
return dest_cpu;
|
|
|
|
|
|
|
|
/* Any allowed, online CPU? */
|
|
|
|
dest_cpu = cpumask_any_and(&p->cpus_allowed, cpu_active_mask);
|
|
|
|
if (dest_cpu < nr_cpu_ids)
|
|
|
|
return dest_cpu;
|
|
|
|
|
|
|
|
/* No more Mr. Nice Guy. */
|
2010-03-15 16:10:03 +07:00
|
|
|
if (unlikely(dest_cpu >= nr_cpu_ids)) {
|
2010-03-15 16:10:27 +07:00
|
|
|
dest_cpu = cpuset_cpus_allowed_fallback(p);
|
2009-12-17 00:04:38 +07:00
|
|
|
/*
|
|
|
|
* Don't tell them about moving exiting tasks or
|
|
|
|
* kernel threads (both mm NULL), since they never
|
|
|
|
* leave kernel.
|
|
|
|
*/
|
|
|
|
if (p->mm && printk_ratelimit()) {
|
|
|
|
printk(KERN_INFO "process %d (%s) no "
|
|
|
|
"longer affine to cpu%d\n",
|
|
|
|
task_pid_nr(p), p->comm, cpu);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dest_cpu;
|
|
|
|
}
|
|
|
|
|
2009-12-17 00:04:36 +07:00
|
|
|
/*
|
2010-03-15 16:10:19 +07:00
|
|
|
* The caller (fork, wakeup) owns TASK_WAKING, ->cpus_allowed is stable.
|
2009-12-17 00:04:36 +07:00
|
|
|
*/
|
2009-11-25 19:31:39 +07:00
|
|
|
static inline
|
2010-03-25 00:34:10 +07:00
|
|
|
int select_task_rq(struct rq *rq, struct task_struct *p, int sd_flags, int wake_flags)
|
2009-11-25 19:31:39 +07:00
|
|
|
{
|
2010-03-25 00:34:10 +07:00
|
|
|
int cpu = p->sched_class->select_task_rq(rq, p, sd_flags, wake_flags);
|
2009-12-17 00:04:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In order not to call set_task_cpu() on a blocking task we need
|
|
|
|
* to rely on ttwu() to place the task on a valid ->cpus_allowed
|
|
|
|
* cpu.
|
|
|
|
*
|
|
|
|
* Since this is common to all placement strategies, this lives here.
|
|
|
|
*
|
|
|
|
* [ this allows ->select_task() to simply return task_cpu(p) and
|
|
|
|
* not worry about this generic constraint ]
|
|
|
|
*/
|
|
|
|
if (unlikely(!cpumask_test_cpu(cpu, &p->cpus_allowed) ||
|
2009-12-20 23:36:27 +07:00
|
|
|
!cpu_online(cpu)))
|
2009-12-17 00:04:38 +07:00
|
|
|
cpu = select_fallback_rq(task_cpu(p), p);
|
2009-12-17 00:04:36 +07:00
|
|
|
|
|
|
|
return cpu;
|
2009-11-25 19:31:39 +07:00
|
|
|
}
|
2010-04-15 12:29:59 +07:00
|
|
|
|
|
|
|
static void update_avg(u64 *avg, u64 sample)
|
|
|
|
{
|
|
|
|
s64 diff = sample - *avg;
|
|
|
|
*avg += diff >> 3;
|
|
|
|
}
|
2009-11-25 19:31:39 +07:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/***
|
|
|
|
* try_to_wake_up - wake up a thread
|
|
|
|
* @p: the to-be-woken-up thread
|
|
|
|
* @state: the mask of task states that can be woken
|
|
|
|
* @sync: do a synchronous wakeup?
|
|
|
|
*
|
|
|
|
* Put it on the run-queue if it's not already there. The "current"
|
|
|
|
* thread is always on the run-queue (except when the actual
|
|
|
|
* re-schedule is in progress), and as such you're allowed to do
|
|
|
|
* the simpler "current->state = TASK_RUNNING" to mark yourself
|
|
|
|
* runnable without the overhead of this.
|
|
|
|
*
|
|
|
|
* returns failure only if the task is already active.
|
|
|
|
*/
|
2009-09-15 00:55:44 +07:00
|
|
|
static int try_to_wake_up(struct task_struct *p, unsigned int state,
|
|
|
|
int wake_flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:18 +07:00
|
|
|
int cpu, orig_cpu, this_cpu, success = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
2010-03-24 22:38:48 +07:00
|
|
|
unsigned long en_flags = ENQUEUE_WAKEUP;
|
2010-03-06 18:17:52 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-15 19:43:03 +07:00
|
|
|
this_cpu = get_cpu();
|
2008-06-27 18:41:35 +07:00
|
|
|
|
2008-02-24 09:05:03 +07:00
|
|
|
smp_wmb();
|
2010-03-06 18:17:52 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
2009-09-15 19:43:03 +07:00
|
|
|
if (!(p->state & state))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
if (p->se.on_rq)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_running;
|
|
|
|
|
|
|
|
cpu = task_cpu(p);
|
2007-10-15 22:00:18 +07:00
|
|
|
orig_cpu = cpu;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (unlikely(task_running(rq, p)))
|
|
|
|
goto out_activate;
|
|
|
|
|
2009-09-15 19:43:03 +07:00
|
|
|
/*
|
|
|
|
* In order to handle concurrent wakeups and release the rq->lock
|
|
|
|
* we put the task in TASK_WAKING state.
|
2009-09-17 02:09:13 +07:00
|
|
|
*
|
|
|
|
* First fix up the nr_uninterruptible count:
|
2009-09-15 19:43:03 +07:00
|
|
|
*/
|
2010-03-26 18:22:14 +07:00
|
|
|
if (task_contributes_to_load(p)) {
|
|
|
|
if (likely(cpu_online(orig_cpu)))
|
|
|
|
rq->nr_uninterruptible--;
|
|
|
|
else
|
|
|
|
this_rq()->nr_uninterruptible--;
|
|
|
|
}
|
2009-09-15 19:43:03 +07:00
|
|
|
p->state = TASK_WAKING;
|
2009-12-17 00:04:40 +07:00
|
|
|
|
2010-03-24 22:38:48 +07:00
|
|
|
if (p->sched_class->task_waking) {
|
2009-12-17 00:04:40 +07:00
|
|
|
p->sched_class->task_waking(rq, p);
|
2010-03-24 22:38:48 +07:00
|
|
|
en_flags |= ENQUEUE_WAKING;
|
|
|
|
}
|
2009-12-17 00:04:40 +07:00
|
|
|
|
2010-03-25 00:34:10 +07:00
|
|
|
cpu = select_task_rq(rq, p, SD_BALANCE_WAKE, wake_flags);
|
|
|
|
if (cpu != orig_cpu)
|
2008-01-26 03:08:21 +07:00
|
|
|
set_task_cpu(p, cpu);
|
2010-03-25 00:34:10 +07:00
|
|
|
__task_rq_unlock(rq);
|
2009-11-27 21:44:43 +07:00
|
|
|
|
2010-02-15 20:45:54 +07:00
|
|
|
rq = cpu_rq(cpu);
|
|
|
|
raw_spin_lock(&rq->lock);
|
2009-10-09 13:35:03 +07:00
|
|
|
|
2010-02-15 20:45:54 +07:00
|
|
|
/*
|
|
|
|
* We migrated the task without holding either rq->lock, however
|
|
|
|
* since the task is not on the task list itself, nobody else
|
|
|
|
* will try and migrate the task, hence the rq should match the
|
|
|
|
* cpu we just moved it to.
|
|
|
|
*/
|
|
|
|
WARN_ON(task_cpu(p) != cpu);
|
2009-09-15 19:43:03 +07:00
|
|
|
WARN_ON(p->state != TASK_WAKING);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-26 03:08:09 +07:00
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
|
|
schedstat_inc(rq, ttwu_count);
|
|
|
|
if (cpu == this_cpu)
|
|
|
|
schedstat_inc(rq, ttwu_local);
|
|
|
|
else {
|
|
|
|
struct sched_domain *sd;
|
|
|
|
for_each_domain(this_cpu, sd) {
|
2008-11-24 23:05:04 +07:00
|
|
|
if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
|
2008-01-26 03:08:09 +07:00
|
|
|
schedstat_inc(sd, ttwu_wake_remote);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_SCHEDSTATS */
|
2008-01-26 03:08:09 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
out_activate:
|
|
|
|
#endif /* CONFIG_SMP */
|
2010-03-11 09:37:45 +07:00
|
|
|
schedstat_inc(p, se.statistics.nr_wakeups);
|
2009-09-15 00:55:44 +07:00
|
|
|
if (wake_flags & WF_SYNC)
|
2010-03-11 09:37:45 +07:00
|
|
|
schedstat_inc(p, se.statistics.nr_wakeups_sync);
|
2007-10-15 22:00:18 +07:00
|
|
|
if (orig_cpu != cpu)
|
2010-03-11 09:37:45 +07:00
|
|
|
schedstat_inc(p, se.statistics.nr_wakeups_migrate);
|
2007-10-15 22:00:18 +07:00
|
|
|
if (cpu == this_cpu)
|
2010-03-11 09:37:45 +07:00
|
|
|
schedstat_inc(p, se.statistics.nr_wakeups_local);
|
2007-10-15 22:00:18 +07:00
|
|
|
else
|
2010-03-11 09:37:45 +07:00
|
|
|
schedstat_inc(p, se.statistics.nr_wakeups_remote);
|
2010-03-24 22:38:48 +07:00
|
|
|
activate_task(rq, p, en_flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
success = 1;
|
|
|
|
|
|
|
|
out_running:
|
2010-05-05 01:36:56 +07:00
|
|
|
trace_sched_wakeup(p, success);
|
2009-09-15 00:55:44 +07:00
|
|
|
check_preempt_curr(rq, p, wake_flags);
|
2008-03-19 07:42:00 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
p->state = TASK_RUNNING;
|
2008-01-26 03:08:22 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2009-12-17 00:04:40 +07:00
|
|
|
if (p->sched_class->task_woken)
|
|
|
|
p->sched_class->task_woken(rq, p);
|
2009-11-10 09:50:02 +07:00
|
|
|
|
|
|
|
if (unlikely(rq->idle_stamp)) {
|
|
|
|
u64 delta = rq->clock - rq->idle_stamp;
|
|
|
|
u64 max = 2*sysctl_sched_migration_cost;
|
|
|
|
|
|
|
|
if (delta > max)
|
|
|
|
rq->avg_idle = max;
|
|
|
|
else
|
|
|
|
update_avg(&rq->avg_idle, delta);
|
|
|
|
rq->idle_stamp = 0;
|
|
|
|
}
|
2008-01-26 03:08:22 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
out:
|
|
|
|
task_rq_unlock(rq, &flags);
|
2009-09-15 19:43:03 +07:00
|
|
|
put_cpu();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
2009-04-28 21:01:38 +07:00
|
|
|
/**
|
|
|
|
* wake_up_process - Wake up a specific process
|
|
|
|
* @p: The process to be woken up.
|
|
|
|
*
|
|
|
|
* Attempt to wake up the nominated process and move it to the set of runnable
|
|
|
|
* processes. Returns 1 if the process was woken up, 0 if it was already
|
|
|
|
* running.
|
|
|
|
*
|
|
|
|
* It may be assumed that this function implies a write memory barrier before
|
|
|
|
* changing the task state if and only if any tasks are woken up.
|
|
|
|
*/
|
2008-02-08 19:19:53 +07:00
|
|
|
int wake_up_process(struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-12-06 23:07:07 +07:00
|
|
|
return try_to_wake_up(p, TASK_ALL, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(wake_up_process);
|
|
|
|
|
2008-02-08 19:19:53 +07:00
|
|
|
int wake_up_state(struct task_struct *p, unsigned int state)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return try_to_wake_up(p, state, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform scheduler related setup for a newly forked process p.
|
|
|
|
* p is forked by current.
|
2007-07-09 23:51:59 +07:00
|
|
|
*
|
|
|
|
* __sched_fork() is basic setup used by init_idle() too:
|
|
|
|
*/
|
|
|
|
static void __sched_fork(struct task_struct *p)
|
|
|
|
{
|
|
|
|
p->se.exec_start = 0;
|
|
|
|
p->se.sum_exec_runtime = 0;
|
2007-08-28 17:53:24 +07:00
|
|
|
p->se.prev_sum_exec_runtime = 0;
|
2008-12-14 18:34:15 +07:00
|
|
|
p->se.nr_migrations = 0;
|
2007-08-02 22:41:40 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
2010-03-11 09:37:45 +07:00
|
|
|
memset(&p->se.statistics, 0, sizeof(p->se.statistics));
|
2007-08-02 22:41:40 +07:00
|
|
|
#endif
|
2005-06-26 04:57:29 +07:00
|
|
|
|
2008-01-26 03:08:27 +07:00
|
|
|
INIT_LIST_HEAD(&p->rt.run_list);
|
2007-07-09 23:51:59 +07:00
|
|
|
p->se.on_rq = 0;
|
2008-04-20 00:45:00 +07:00
|
|
|
INIT_LIST_HEAD(&p->se.group_node);
|
2005-06-26 04:57:29 +07:00
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
#ifdef CONFIG_PREEMPT_NOTIFIERS
|
|
|
|
INIT_HLIST_HEAD(&p->preempt_notifiers);
|
|
|
|
#endif
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fork()/clone()-time setup:
|
|
|
|
*/
|
|
|
|
void sched_fork(struct task_struct *p, int clone_flags)
|
|
|
|
{
|
|
|
|
int cpu = get_cpu();
|
|
|
|
|
|
|
|
__sched_fork(p);
|
2009-12-17 00:04:35 +07:00
|
|
|
/*
|
2010-03-25 00:34:10 +07:00
|
|
|
* We mark the process as running here. This guarantees that
|
2009-12-17 00:04:35 +07:00
|
|
|
* nobody will actually run it, and a signal or other external
|
|
|
|
* event cannot wake it up and insert it on the runqueue either.
|
|
|
|
*/
|
2010-03-25 00:34:10 +07:00
|
|
|
p->state = TASK_RUNNING;
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2009-06-17 15:46:01 +07:00
|
|
|
/*
|
|
|
|
* Revert to default priority/policy on fork if requested.
|
|
|
|
*/
|
|
|
|
if (unlikely(p->sched_reset_on_fork)) {
|
2009-09-24 13:47:10 +07:00
|
|
|
if (p->policy == SCHED_FIFO || p->policy == SCHED_RR) {
|
2009-06-17 15:46:01 +07:00
|
|
|
p->policy = SCHED_NORMAL;
|
2009-09-24 13:47:10 +07:00
|
|
|
p->normal_prio = p->static_prio;
|
|
|
|
}
|
2009-06-17 15:46:01 +07:00
|
|
|
|
2009-06-17 15:48:02 +07:00
|
|
|
if (PRIO_TO_NICE(p->static_prio) < 0) {
|
|
|
|
p->static_prio = NICE_TO_PRIO(0);
|
2009-09-24 13:47:10 +07:00
|
|
|
p->normal_prio = p->static_prio;
|
2009-06-17 15:48:02 +07:00
|
|
|
set_load_weight(p);
|
|
|
|
}
|
|
|
|
|
2009-06-17 15:46:01 +07:00
|
|
|
/*
|
|
|
|
* We don't need the reset flag anymore after the fork. It has
|
|
|
|
* fulfilled its duty:
|
|
|
|
*/
|
|
|
|
p->sched_reset_on_fork = 0;
|
|
|
|
}
|
2009-06-15 22:17:47 +07:00
|
|
|
|
2009-09-24 13:47:10 +07:00
|
|
|
/*
|
|
|
|
* Make sure we do not leak PI boosting priority to the child.
|
|
|
|
*/
|
|
|
|
p->prio = current->normal_prio;
|
|
|
|
|
2007-10-15 22:00:11 +07:00
|
|
|
if (!rt_prio(p->prio))
|
|
|
|
p->sched_class = &fair_sched_class;
|
2006-06-27 16:54:51 +07:00
|
|
|
|
2009-11-27 23:32:46 +07:00
|
|
|
if (p->sched_class->task_fork)
|
|
|
|
p->sched_class->task_fork(p);
|
|
|
|
|
2010-06-22 16:44:53 +07:00
|
|
|
/*
|
|
|
|
* The child is not yet in the pid-hash so no cgroup attach races,
|
|
|
|
* and the cgroup is pinned to this child due to cgroup_fork()
|
|
|
|
* is ran before sched_fork().
|
|
|
|
*
|
|
|
|
* Silence PROVE_RCU.
|
|
|
|
*/
|
|
|
|
rcu_read_lock();
|
2009-09-10 18:42:00 +07:00
|
|
|
set_task_cpu(p, cpu);
|
2010-06-22 16:44:53 +07:00
|
|
|
rcu_read_unlock();
|
2009-09-10 18:42:00 +07:00
|
|
|
|
2006-07-14 14:24:38 +07:00
|
|
|
#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
|
2007-07-09 23:51:59 +07:00
|
|
|
if (likely(sched_info_on()))
|
2006-07-14 14:24:38 +07:00
|
|
|
memset(&p->sched_info, 0, sizeof(p->sched_info));
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
[PATCH] sched: revert "filter affine wakeups"
Revert commit d7102e95b7b9c00277562c29aad421d2d521c5f6:
[PATCH] sched: filter affine wakeups
Apparently caused more than 10% performance regression for aim7 benchmark.
The setup in use is 16-cpu HP rx8620, 64Gb of memory and 12 MSA1000s with 144
disks. Each disk is 72Gb with a single ext3 filesystem (courtesy of HP, who
supplied benchmark results).
The problem is, for aim7, the wake-up pattern is random, but it still needs
load balancing action in the wake-up path to achieve best performance. With
the above commit, lack of load balancing hurts that workload.
However, for workloads like database transaction processing, the requirement
is exactly opposite. In the wake up path, best performance is achieved with
absolutely zero load balancing. We simply wake up the process on the CPU that
it was previously run. Worst performance is obtained when we do load
balancing at wake up.
There isn't an easy way to auto detect the workload characteristics. Ingo's
earlier patch that detects idle CPU and decide whether to load balance or not
doesn't perform with aim7 either since all CPUs are busy (it causes even
bigger perf. regression).
Revert commit d7102e95b7b9c00277562c29aad421d2d521c5f6, which causes more
than 10% performance regression with aim7.
Signed-off-by: Ken Chen <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-02-15 04:53:10 +07:00
|
|
|
#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
|
2005-06-26 04:57:23 +07:00
|
|
|
p->oncpu = 0;
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_PREEMPT
|
2005-06-26 04:57:23 +07:00
|
|
|
/* Want to start with kernel preemption disabled. */
|
2005-11-14 07:06:55 +07:00
|
|
|
task_thread_info(p)->preempt_count = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
sched: create "pushable_tasks" list to limit pushing to one attempt
The RT scheduler employs a "push/pull" design to actively balance tasks
within the system (on a per disjoint cpuset basis). When a task is
awoken, it is immediately determined if there are any lower priority
cpus which should be preempted. This is opposed to the way normal
SCHED_OTHER tasks behave, which will wait for a periodic rebalancing
operation to occur before spreading out load.
When a particular RQ has more than 1 active RT task, it is said to
be in an "overloaded" state. Once this occurs, the system enters
the active balancing mode, where it will try to push the task away,
or persuade a different cpu to pull it over. The system will stay
in this state until the system falls back below the <= 1 queued RT
task per RQ.
However, the current implementation suffers from a limitation in the
push logic. Once overloaded, all tasks (other than current) on the
RQ are analyzed on every push operation, even if it was previously
unpushable (due to affinity, etc). Whats more, the operation stops
at the first task that is unpushable and will not look at items
lower in the queue. This causes two problems:
1) We can have the same tasks analyzed over and over again during each
push, which extends out the fast path in the scheduler for no
gain. Consider a RQ that has dozens of tasks that are bound to a
core. Each one of those tasks will be encountered and skipped
for each push operation while they are queued.
2) There may be lower-priority tasks under the unpushable task that
could have been successfully pushed, but will never be considered
until either the unpushable task is cleared, or a pull operation
succeeds. The net result is a potential latency source for mid
priority tasks.
This patch aims to rectify these two conditions by introducing a new
priority sorted list: "pushable_tasks". A task is added to the list
each time a task is activated or preempted. It is removed from the
list any time it is deactivated, made current, or fails to push.
This works because a task only needs to be attempted to push once.
After an initial failure to push, the other cpus will eventually try to
pull the task when the conditions are proper. This also solves the
problem that we don't completely analyze all tasks due to encountering
an unpushable tasks. Now every task will have a push attempted (when
appropriate).
This reduces latency both by shorting the critical section of the
rq->lock for certain workloads, and by making sure the algorithm
considers all eligible tasks in the system.
[ rostedt: added a couple more BUG_ONs ]
Signed-off-by: Gregory Haskins <ghaskins@novell.com>
Acked-by: Steven Rostedt <srostedt@redhat.com>
2008-12-29 21:39:53 +07:00
|
|
|
plist_node_init(&p->pushable_tasks, MAX_PRIO);
|
|
|
|
|
2005-06-26 04:57:29 +07:00
|
|
|
put_cpu();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* wake_up_new_task - wake up a newly created task for the first time.
|
|
|
|
*
|
|
|
|
* This function will do some initial scheduler statistics housekeeping
|
|
|
|
* that must be done for every newly created context, then puts the task
|
|
|
|
* on the runqueue and wakes it.
|
|
|
|
*/
|
2008-02-08 19:19:53 +07:00
|
|
|
void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-07-09 23:51:59 +07:00
|
|
|
struct rq *rq;
|
2010-03-12 05:08:43 +07:00
|
|
|
int cpu __maybe_unused = get_cpu();
|
2010-01-22 03:04:57 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2010-03-25 00:34:10 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
|
|
|
p->state = TASK_WAKING;
|
|
|
|
|
2010-01-22 03:04:57 +07:00
|
|
|
/*
|
|
|
|
* Fork balancing, do it here and not earlier because:
|
|
|
|
* - cpus_allowed can change in the fork path
|
|
|
|
* - any previously selected cpu might disappear through hotplug
|
|
|
|
*
|
2010-03-25 00:34:10 +07:00
|
|
|
* We set TASK_WAKING so that select_task_rq() can drop rq->lock
|
|
|
|
* without people poking at ->cpus_allowed.
|
2010-01-22 03:04:57 +07:00
|
|
|
*/
|
2010-03-25 00:34:10 +07:00
|
|
|
cpu = select_task_rq(rq, p, SD_BALANCE_FORK, 0);
|
2010-01-22 03:04:57 +07:00
|
|
|
set_task_cpu(p, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-12-17 00:04:35 +07:00
|
|
|
p->state = TASK_RUNNING;
|
2010-03-25 00:34:10 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
rq = task_rq_lock(p, &flags);
|
2009-11-27 23:32:46 +07:00
|
|
|
activate_task(rq, p, 0);
|
2010-05-05 01:36:56 +07:00
|
|
|
trace_sched_wakeup_new(p, 1);
|
2009-09-15 01:02:34 +07:00
|
|
|
check_preempt_curr(rq, p, WF_FORK);
|
2008-01-26 03:08:22 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2009-12-17 00:04:40 +07:00
|
|
|
if (p->sched_class->task_woken)
|
|
|
|
p->sched_class->task_woken(rq, p);
|
2008-01-26 03:08:22 +07:00
|
|
|
#endif
|
2007-07-09 23:51:59 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
2010-01-22 03:04:57 +07:00
|
|
|
put_cpu();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
#ifdef CONFIG_PREEMPT_NOTIFIERS
|
|
|
|
|
|
|
|
/**
|
2009-03-17 02:58:09 +07:00
|
|
|
* preempt_notifier_register - tell me when current is being preempted & rescheduled
|
2007-07-31 14:37:50 +07:00
|
|
|
* @notifier: notifier struct to register
|
2007-07-26 18:40:43 +07:00
|
|
|
*/
|
|
|
|
void preempt_notifier_register(struct preempt_notifier *notifier)
|
|
|
|
{
|
|
|
|
hlist_add_head(¬ifier->link, ¤t->preempt_notifiers);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(preempt_notifier_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* preempt_notifier_unregister - no longer interested in preemption notifications
|
2007-07-31 14:37:50 +07:00
|
|
|
* @notifier: notifier struct to unregister
|
2007-07-26 18:40:43 +07:00
|
|
|
*
|
|
|
|
* This is safe to call from within a preemption notifier.
|
|
|
|
*/
|
|
|
|
void preempt_notifier_unregister(struct preempt_notifier *notifier)
|
|
|
|
{
|
|
|
|
hlist_del(¬ifier->link);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(preempt_notifier_unregister);
|
|
|
|
|
|
|
|
static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
|
|
|
|
{
|
|
|
|
struct preempt_notifier *notifier;
|
|
|
|
struct hlist_node *node;
|
|
|
|
|
|
|
|
hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
|
|
|
|
notifier->ops->sched_in(notifier, raw_smp_processor_id());
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fire_sched_out_preempt_notifiers(struct task_struct *curr,
|
|
|
|
struct task_struct *next)
|
|
|
|
{
|
|
|
|
struct preempt_notifier *notifier;
|
|
|
|
struct hlist_node *node;
|
|
|
|
|
|
|
|
hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
|
|
|
|
notifier->ops->sched_out(notifier, next);
|
|
|
|
}
|
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFIG_PREEMPT_NOTIFIERS */
|
2007-07-26 18:40:43 +07:00
|
|
|
|
|
|
|
static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fire_sched_out_preempt_notifiers(struct task_struct *curr,
|
|
|
|
struct task_struct *next)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_PREEMPT_NOTIFIERS */
|
2007-07-26 18:40:43 +07:00
|
|
|
|
2005-06-26 04:57:23 +07:00
|
|
|
/**
|
|
|
|
* prepare_task_switch - prepare to switch tasks
|
|
|
|
* @rq: the runqueue preparing to switch
|
2007-07-31 14:37:50 +07:00
|
|
|
* @prev: the current task that is being switched out
|
2005-06-26 04:57:23 +07:00
|
|
|
* @next: the task we are going to switch to.
|
|
|
|
*
|
|
|
|
* This is called with the rq lock held and interrupts off. It must
|
|
|
|
* be paired with a subsequent finish_task_switch after the context
|
|
|
|
* switch.
|
|
|
|
*
|
|
|
|
* prepare_task_switch sets up locking and calls architecture specific
|
|
|
|
* hooks.
|
|
|
|
*/
|
2007-07-26 18:40:43 +07:00
|
|
|
static inline void
|
|
|
|
prepare_task_switch(struct rq *rq, struct task_struct *prev,
|
|
|
|
struct task_struct *next)
|
2005-06-26 04:57:23 +07:00
|
|
|
{
|
2007-07-26 18:40:43 +07:00
|
|
|
fire_sched_out_preempt_notifiers(prev, next);
|
2005-06-26 04:57:23 +07:00
|
|
|
prepare_lock_switch(rq, next);
|
|
|
|
prepare_arch_switch(next);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* finish_task_switch - clean up after a task-switch
|
2005-09-07 12:15:17 +07:00
|
|
|
* @rq: runqueue associated with task-switch
|
2005-04-17 05:20:36 +07:00
|
|
|
* @prev: the thread we just switched away from.
|
|
|
|
*
|
2005-06-26 04:57:23 +07:00
|
|
|
* finish_task_switch must be called after the context switch, paired
|
|
|
|
* with a prepare_task_switch call before the context switch.
|
|
|
|
* finish_task_switch will reconcile locking set up by prepare_task_switch,
|
|
|
|
* and do any other architecture-specific cleanup actions.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Note that we may have delayed dropping an mm in context_switch(). If
|
2007-12-05 21:46:09 +07:00
|
|
|
* so, we finish that here outside of the runqueue lock. (Doing it
|
2005-04-17 05:20:36 +07:00
|
|
|
* with the lock held can cause deadlocks; see schedule() for
|
|
|
|
* details.)
|
|
|
|
*/
|
2007-10-15 22:00:13 +07:00
|
|
|
static void finish_task_switch(struct rq *rq, struct task_struct *prev)
|
2005-04-17 05:20:36 +07:00
|
|
|
__releases(rq->lock)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = rq->prev_mm;
|
2006-09-29 16:01:10 +07:00
|
|
|
long prev_state;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rq->prev_mm = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A task struct has one reference for the use as "current".
|
2006-09-29 16:01:11 +07:00
|
|
|
* If a task dies, then it sets TASK_DEAD in tsk->state and calls
|
2006-09-29 16:01:10 +07:00
|
|
|
* schedule one last time. The schedule call will never return, and
|
|
|
|
* the scheduled task must drop that reference.
|
2006-09-29 16:01:11 +07:00
|
|
|
* The test for TASK_DEAD must occur while the runqueue locks are
|
2005-04-17 05:20:36 +07:00
|
|
|
* still held, otherwise prev could be scheduled on another cpu, die
|
|
|
|
* there before we look at prev->state, and then the reference would
|
|
|
|
* be dropped twice.
|
|
|
|
* Manfred Spraul <manfred@colorfullife.com>
|
|
|
|
*/
|
2006-09-29 16:01:10 +07:00
|
|
|
prev_state = prev->state;
|
2005-06-26 04:57:23 +07:00
|
|
|
finish_arch_switch(prev);
|
2010-01-08 22:27:33 +07:00
|
|
|
#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
|
|
|
|
local_irq_disable();
|
|
|
|
#endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
|
2009-12-27 17:51:52 +07:00
|
|
|
perf_event_task_sched_in(current);
|
2010-01-08 22:27:33 +07:00
|
|
|
#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
|
|
|
|
local_irq_enable();
|
|
|
|
#endif /* __ARCH_WANT_INTERRUPTS_ON_CTXSW */
|
2005-06-26 04:57:23 +07:00
|
|
|
finish_lock_switch(rq, prev);
|
2008-01-26 03:08:05 +07:00
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
fire_sched_in_preempt_notifiers(current);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (mm)
|
|
|
|
mmdrop(mm);
|
2006-09-29 16:01:11 +07:00
|
|
|
if (unlikely(prev_state == TASK_DEAD)) {
|
2006-03-26 16:38:20 +07:00
|
|
|
/*
|
|
|
|
* Remove function-return probe instances associated with this
|
|
|
|
* task and put them back on the free list.
|
2007-07-09 23:52:00 +07:00
|
|
|
*/
|
2006-03-26 16:38:20 +07:00
|
|
|
kprobe_flush_task(prev);
|
2005-04-17 05:20:36 +07:00
|
|
|
put_task_struct(prev);
|
2006-03-26 16:38:20 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-07-29 22:08:47 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
|
|
|
/* assumes rq->lock is held */
|
|
|
|
static inline void pre_schedule(struct rq *rq, struct task_struct *prev)
|
|
|
|
{
|
|
|
|
if (prev->sched_class->pre_schedule)
|
|
|
|
prev->sched_class->pre_schedule(rq, prev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* rq->lock is NOT held, but preemption is disabled */
|
|
|
|
static inline void post_schedule(struct rq *rq)
|
|
|
|
{
|
|
|
|
if (rq->post_schedule) {
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2009-07-29 22:08:47 +07:00
|
|
|
if (rq->curr->sched_class->post_schedule)
|
|
|
|
rq->curr->sched_class->post_schedule(rq);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2009-07-29 22:08:47 +07:00
|
|
|
|
|
|
|
rq->post_schedule = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
2009-07-29 11:21:22 +07:00
|
|
|
|
2009-07-29 22:08:47 +07:00
|
|
|
static inline void pre_schedule(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void post_schedule(struct rq *rq)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-07-29 22:08:47 +07:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* schedule_tail - first thing a freshly forked thread must call.
|
|
|
|
* @prev: the thread we just switched away from.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
asmlinkage void schedule_tail(struct task_struct *prev)
|
2005-04-17 05:20:36 +07:00
|
|
|
__releases(rq->lock)
|
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = this_rq();
|
|
|
|
|
2005-06-26 04:57:23 +07:00
|
|
|
finish_task_switch(rq, prev);
|
2009-07-29 11:21:22 +07:00
|
|
|
|
2009-07-29 22:08:47 +07:00
|
|
|
/*
|
|
|
|
* FIXME: do we need to worry about rq being invalidated by the
|
|
|
|
* task_switch?
|
|
|
|
*/
|
|
|
|
post_schedule(rq);
|
2006-07-03 14:25:42 +07:00
|
|
|
|
2005-06-26 04:57:23 +07:00
|
|
|
#ifdef __ARCH_WANT_UNLOCKED_CTXSW
|
|
|
|
/* In this case, finish_task_switch does not reenable preemption */
|
|
|
|
preempt_enable();
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
if (current->set_child_tid)
|
2007-10-19 13:40:14 +07:00
|
|
|
put_user(task_pid_vnr(current), current->set_child_tid);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* context_switch - switch to the new MM and the new
|
|
|
|
* thread's register state.
|
|
|
|
*/
|
2007-07-09 23:51:59 +07:00
|
|
|
static inline void
|
2006-07-03 14:25:42 +07:00
|
|
|
context_switch(struct rq *rq, struct task_struct *prev,
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *next)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-07-09 23:51:59 +07:00
|
|
|
struct mm_struct *mm, *oldmm;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
prepare_task_switch(rq, prev, next);
|
2010-05-05 01:36:56 +07:00
|
|
|
trace_sched_switch(prev, next);
|
2007-07-09 23:51:59 +07:00
|
|
|
mm = next->mm;
|
|
|
|
oldmm = prev->active_mm;
|
2007-02-13 19:26:21 +07:00
|
|
|
/*
|
|
|
|
* For paravirt, this is coupled with an exit in switch_to to
|
|
|
|
* combine the page table reload and the switch backend into
|
|
|
|
* one hypercall.
|
|
|
|
*/
|
2009-02-19 02:18:57 +07:00
|
|
|
arch_start_context_switch(prev);
|
2007-02-13 19:26:21 +07:00
|
|
|
|
2009-11-24 17:55:27 +07:00
|
|
|
if (likely(!mm)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
next->active_mm = oldmm;
|
|
|
|
atomic_inc(&oldmm->mm_count);
|
|
|
|
enter_lazy_tlb(oldmm, next);
|
|
|
|
} else
|
|
|
|
switch_mm(oldmm, mm, next);
|
|
|
|
|
2009-11-24 17:55:27 +07:00
|
|
|
if (likely(!prev->mm)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
prev->active_mm = NULL;
|
|
|
|
rq->prev_mm = oldmm;
|
|
|
|
}
|
2006-07-14 14:24:27 +07:00
|
|
|
/*
|
|
|
|
* Since the runqueue lock will be released by the next
|
|
|
|
* task (which is an invalid locking op but in the case
|
|
|
|
* of the scheduler it's an obvious special-case), so we
|
|
|
|
* do an early lockdep release here:
|
|
|
|
*/
|
|
|
|
#ifndef __ARCH_WANT_UNLOCKED_CTXSW
|
2006-07-03 14:24:54 +07:00
|
|
|
spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
|
2006-07-14 14:24:27 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Here we just switch the register state and the stack. */
|
|
|
|
switch_to(prev, next, prev);
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
barrier();
|
|
|
|
/*
|
|
|
|
* this_rq must be evaluated again because prev may have moved
|
|
|
|
* CPUs since it called schedule(), thus the 'rq' on its stack
|
|
|
|
* frame will be invalid.
|
|
|
|
*/
|
|
|
|
finish_task_switch(this_rq(), prev);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nr_running, nr_uninterruptible and nr_context_switches:
|
|
|
|
*
|
|
|
|
* externally visible scheduler statistics: current number of runnable
|
|
|
|
* threads, current number of uninterruptible-sleeping threads, total
|
|
|
|
* number of context switches performed since bootup.
|
|
|
|
*/
|
|
|
|
unsigned long nr_running(void)
|
|
|
|
{
|
|
|
|
unsigned long i, sum = 0;
|
|
|
|
|
|
|
|
for_each_online_cpu(i)
|
|
|
|
sum += cpu_rq(i)->nr_running;
|
|
|
|
|
|
|
|
return sum;
|
2009-04-14 11:55:30 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
unsigned long nr_uninterruptible(void)
|
2009-04-14 11:55:30 +07:00
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long i, sum = 0;
|
2009-04-14 11:55:30 +07:00
|
|
|
|
2006-03-28 16:56:37 +07:00
|
|
|
for_each_possible_cpu(i)
|
2005-04-17 05:20:36 +07:00
|
|
|
sum += cpu_rq(i)->nr_uninterruptible;
|
2009-04-14 11:55:30 +07:00
|
|
|
|
|
|
|
/*
|
2005-04-17 05:20:36 +07:00
|
|
|
* Since we read the counters lockless, it might be slightly
|
|
|
|
* inaccurate. Do not allow it to go below zero though:
|
2009-04-14 11:55:30 +07:00
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
if (unlikely((long)sum < 0))
|
|
|
|
sum = 0;
|
2009-04-14 11:55:30 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return sum;
|
2009-04-14 11:55:30 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long long nr_context_switches(void)
|
2007-05-08 14:32:51 +07:00
|
|
|
{
|
2006-06-27 16:54:31 +07:00
|
|
|
int i;
|
|
|
|
unsigned long long sum = 0;
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2006-03-28 16:56:37 +07:00
|
|
|
for_each_possible_cpu(i)
|
2005-04-17 05:20:36 +07:00
|
|
|
sum += cpu_rq(i)->nr_switches;
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return sum;
|
|
|
|
}
|
2009-02-05 02:59:44 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long nr_iowait(void)
|
|
|
|
{
|
|
|
|
unsigned long i, sum = 0;
|
2009-02-05 02:59:44 +07:00
|
|
|
|
2006-03-28 16:56:37 +07:00
|
|
|
for_each_possible_cpu(i)
|
2005-04-17 05:20:36 +07:00
|
|
|
sum += atomic_read(&cpu_rq(i)->nr_iowait);
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return sum;
|
|
|
|
}
|
2009-02-05 02:59:44 +07:00
|
|
|
|
2010-07-01 14:07:17 +07:00
|
|
|
unsigned long nr_iowait_cpu(int cpu)
|
2009-09-22 07:04:08 +07:00
|
|
|
{
|
2010-07-01 14:07:17 +07:00
|
|
|
struct rq *this = cpu_rq(cpu);
|
2009-09-22 07:04:08 +07:00
|
|
|
return atomic_read(&this->nr_iowait);
|
|
|
|
}
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2009-09-22 07:04:08 +07:00
|
|
|
unsigned long this_cpu_load(void)
|
|
|
|
{
|
|
|
|
struct rq *this = this_rq();
|
|
|
|
return this->cpu_load[0];
|
|
|
|
}
|
2009-04-14 11:55:35 +07:00
|
|
|
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
/* Variables and functions for calc_load */
|
|
|
|
static atomic_long_t calc_load_tasks;
|
|
|
|
static unsigned long calc_load_update;
|
|
|
|
unsigned long avenrun[3];
|
|
|
|
EXPORT_SYMBOL(avenrun);
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2010-04-23 02:50:19 +07:00
|
|
|
static long calc_load_fold_active(struct rq *this_rq)
|
|
|
|
{
|
|
|
|
long nr_active, delta = 0;
|
|
|
|
|
|
|
|
nr_active = this_rq->nr_running;
|
|
|
|
nr_active += (long) this_rq->nr_uninterruptible;
|
|
|
|
|
|
|
|
if (nr_active != this_rq->calc_load_active) {
|
|
|
|
delta = nr_active - this_rq->calc_load_active;
|
|
|
|
this_rq->calc_load_active = nr_active;
|
|
|
|
}
|
|
|
|
|
|
|
|
return delta;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NO_HZ
|
|
|
|
/*
|
|
|
|
* For NO_HZ we delay the active fold to the next LOAD_FREQ update.
|
|
|
|
*
|
|
|
|
* When making the ILB scale, we should try to pull this in as well.
|
|
|
|
*/
|
|
|
|
static atomic_long_t calc_load_tasks_idle;
|
|
|
|
|
|
|
|
static void calc_load_account_idle(struct rq *this_rq)
|
|
|
|
{
|
|
|
|
long delta;
|
|
|
|
|
|
|
|
delta = calc_load_fold_active(this_rq);
|
|
|
|
if (delta)
|
|
|
|
atomic_long_add(delta, &calc_load_tasks_idle);
|
|
|
|
}
|
|
|
|
|
|
|
|
static long calc_load_fold_idle(void)
|
|
|
|
{
|
|
|
|
long delta = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Its got a race, we don't care...
|
|
|
|
*/
|
|
|
|
if (atomic_long_read(&calc_load_tasks_idle))
|
|
|
|
delta = atomic_long_xchg(&calc_load_tasks_idle, 0);
|
|
|
|
|
|
|
|
return delta;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void calc_load_account_idle(struct rq *this_rq)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline long calc_load_fold_idle(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-05-03 01:08:52 +07:00
|
|
|
/**
|
|
|
|
* get_avenrun - get the load average array
|
|
|
|
* @loads: pointer to dest load array
|
|
|
|
* @offset: offset to add
|
|
|
|
* @shift: shift count to shift the result left
|
|
|
|
*
|
|
|
|
* These values are estimates at best, so no need for locking.
|
|
|
|
*/
|
|
|
|
void get_avenrun(unsigned long *loads, unsigned long offset, int shift)
|
|
|
|
{
|
|
|
|
loads[0] = (avenrun[0] + offset) << shift;
|
|
|
|
loads[1] = (avenrun[1] + offset) << shift;
|
|
|
|
loads[2] = (avenrun[2] + offset) << shift;
|
2007-05-08 14:32:51 +07:00
|
|
|
}
|
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
static unsigned long
|
|
|
|
calc_load(unsigned long load, unsigned long exp, unsigned long active)
|
2006-03-31 17:31:21 +07:00
|
|
|
{
|
2009-04-11 15:43:41 +07:00
|
|
|
load *= exp;
|
|
|
|
load += active * (FIXED_1 - exp);
|
|
|
|
return load >> FSHIFT;
|
|
|
|
}
|
2007-05-08 14:32:51 +07:00
|
|
|
|
|
|
|
/*
|
2009-04-11 15:43:41 +07:00
|
|
|
* calc_load - update the avenrun load estimates 10 ticks after the
|
|
|
|
* CPUs have updated calc_load_tasks.
|
2006-12-10 17:20:22 +07:00
|
|
|
*/
|
2009-04-11 15:43:41 +07:00
|
|
|
void calc_global_load(void)
|
2006-12-10 17:20:22 +07:00
|
|
|
{
|
2009-04-11 15:43:41 +07:00
|
|
|
unsigned long upd = calc_load_update + 10;
|
|
|
|
long active;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
if (time_before(jiffies, upd))
|
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
active = atomic_long_read(&calc_load_tasks);
|
|
|
|
active = active > 0 ? active * FIXED_1 : 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
avenrun[0] = calc_load(avenrun[0], EXP_1, active);
|
|
|
|
avenrun[1] = calc_load(avenrun[1], EXP_5, active);
|
|
|
|
avenrun[2] = calc_load(avenrun[2], EXP_15, active);
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
calc_load_update += LOAD_FREQ;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-11 15:43:41 +07:00
|
|
|
/*
|
2010-04-23 02:50:19 +07:00
|
|
|
* Called from update_cpu_load() to periodically update this CPU's
|
|
|
|
* active count.
|
2009-04-11 15:43:41 +07:00
|
|
|
*/
|
|
|
|
static void calc_load_account_active(struct rq *this_rq)
|
|
|
|
{
|
2010-04-23 02:50:19 +07:00
|
|
|
long delta;
|
2006-12-10 17:20:29 +07:00
|
|
|
|
2010-04-23 02:50:19 +07:00
|
|
|
if (time_before(jiffies, this_rq->calc_load_update))
|
|
|
|
return;
|
2006-12-10 17:20:33 +07:00
|
|
|
|
2010-04-23 02:50:19 +07:00
|
|
|
delta = calc_load_fold_active(this_rq);
|
|
|
|
delta += calc_load_fold_idle();
|
|
|
|
if (delta)
|
2009-04-11 15:43:41 +07:00
|
|
|
atomic_long_add(delta, &calc_load_tasks);
|
2010-04-23 02:50:19 +07:00
|
|
|
|
|
|
|
this_rq->calc_load_update += LOAD_FREQ;
|
2007-05-08 14:32:51 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-07-09 23:51:59 +07:00
|
|
|
* Update rq->cpu_load[] statistics. This function is usually called every
|
|
|
|
* scheduler tick (TICK_NSEC).
|
2007-05-08 14:32:51 +07:00
|
|
|
*/
|
2007-07-09 23:51:59 +07:00
|
|
|
static void update_cpu_load(struct rq *this_rq)
|
2007-05-08 14:32:51 +07:00
|
|
|
{
|
2007-10-15 22:00:06 +07:00
|
|
|
unsigned long this_load = this_rq->load.weight;
|
2007-07-09 23:51:59 +07:00
|
|
|
int i, scale;
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
this_rq->nr_load_updates++;
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/* Update our load: */
|
|
|
|
for (i = 0, scale = 1; i < CPU_LOAD_IDX_MAX; i++, scale += scale) {
|
|
|
|
unsigned long old_load, new_load;
|
2008-11-24 23:05:09 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/* scale is effectively 1 << i now, and >> i divides by scale */
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
old_load = this_rq->cpu_load[i];
|
|
|
|
new_load = this_load;
|
2007-10-15 22:00:03 +07:00
|
|
|
/*
|
|
|
|
* Round up the averaging division if load is increasing. This
|
|
|
|
* prevents us from getting stuck on 9 if the load is 10, for
|
|
|
|
* example.
|
|
|
|
*/
|
|
|
|
if (new_load > old_load)
|
|
|
|
new_load += scale-1;
|
2007-07-09 23:51:59 +07:00
|
|
|
this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) >> i;
|
|
|
|
}
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2010-04-23 02:50:19 +07:00
|
|
|
calc_load_account_active(this_rq);
|
2007-05-08 14:32:51 +07:00
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
#ifdef CONFIG_SMP
|
sched: don't rebalance if attached on NULL domain
Impact: fix function graph trace hang / drop pointless softirq on UP
While debugging a function graph trace hang on an old PII, I saw
that it consumed most of its time on the timer interrupt. And
the domain rebalancing softirq was the most concerned.
The timer interrupt calls trigger_load_balance() which will
decide if it is worth to schedule a rebalancing softirq.
In case of builtin UP kernel, no problem arises because there is
no domain question.
In case of builtin SMP kernel running on an SMP box, still no
problem, the softirq will be raised each time we reach the
next_balance time.
In case of builtin SMP kernel running on a UP box (most distros
provide default SMP kernels, whatever the box you have), then
the CPU is attached to the NULL sched domain. So a kind of
unexpected behaviour happen:
trigger_load_balance() -> raises the rebalancing softirq later
on softirq: run_rebalance_domains() -> rebalance_domains() where
the for_each_domain(cpu, sd) is not taken because of the NULL
domain we are attached at. Which means rq->next_balance is never
updated. So on the next timer tick, we will enter
trigger_load_balance() which will always reschedule() the
rebalacing softirq:
if (time_after_eq(jiffies, rq->next_balance))
raise_softirq(SCHED_SOFTIRQ);
So for each tick, we process this pointless softirq.
This patch fixes it by checking if we are attached to the null
domain before raising the softirq, another possible fix would be
to set the maximal possible JIFFIES value to rq->next_balance if
we are attached to the NULL domain.
v2: build fix on UP
Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Peter Zijlstra <peterz@infradead.org>
LKML-Reference: <49af242d.1c07d00a.32d5.ffffc019@mx.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-03-05 07:27:02 +07:00
|
|
|
|
2007-05-08 14:32:51 +07:00
|
|
|
/*
|
2009-12-17 00:04:37 +07:00
|
|
|
* sched_exec - execve() is a valuable balancing opportunity, because at
|
|
|
|
* this point the task has the smallest effective memory and cache footprint.
|
2007-05-08 14:32:51 +07:00
|
|
|
*/
|
2009-12-17 00:04:37 +07:00
|
|
|
void sched_exec(void)
|
2007-05-08 14:32:51 +07:00
|
|
|
{
|
2009-12-17 00:04:37 +07:00
|
|
|
struct task_struct *p = current;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2010-03-25 00:34:10 +07:00
|
|
|
int dest_cpu;
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
2010-03-25 00:34:10 +07:00
|
|
|
dest_cpu = p->sched_class->select_task_rq(rq, p, SD_BALANCE_EXEC, 0);
|
|
|
|
if (dest_cpu == smp_processor_id())
|
|
|
|
goto unlock;
|
2009-12-17 00:04:37 +07:00
|
|
|
|
2007-05-08 14:32:51 +07:00
|
|
|
/*
|
2009-12-17 00:04:37 +07:00
|
|
|
* select_task_rq() can race against ->cpus_allowed
|
2007-05-08 14:32:51 +07:00
|
|
|
*/
|
2010-03-15 16:10:19 +07:00
|
|
|
if (cpumask_test_cpu(dest_cpu, &p->cpus_allowed) &&
|
2010-05-06 23:49:21 +07:00
|
|
|
likely(cpu_active(dest_cpu)) && migrate_task(p, dest_cpu)) {
|
|
|
|
struct migration_arg arg = { p, dest_cpu };
|
2007-05-08 14:32:51 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
2010-05-06 23:49:21 +07:00
|
|
|
stop_one_cpu(cpu_of(rq), migration_cpu_stop, &arg);
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
}
|
2010-03-25 00:34:10 +07:00
|
|
|
unlock:
|
2005-04-17 05:20:36 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
DEFINE_PER_CPU(struct kernel_stat, kstat);
|
|
|
|
|
|
|
|
EXPORT_PER_CPU_SYMBOL(kstat);
|
|
|
|
|
|
|
|
/*
|
2009-03-31 14:56:03 +07:00
|
|
|
* Return any ns on the sched_clock that have not yet been accounted in
|
timers: fix itimer/many thread hang
Overview
This patch reworks the handling of POSIX CPU timers, including the
ITIMER_PROF, ITIMER_VIRT timers and rlimit handling. It was put together
with the help of Roland McGrath, the owner and original writer of this code.
The problem we ran into, and the reason for this rework, has to do with using
a profiling timer in a process with a large number of threads. It appears
that the performance of the old implementation of run_posix_cpu_timers() was
at least O(n*3) (where "n" is the number of threads in a process) or worse.
Everything is fine with an increasing number of threads until the time taken
for that routine to run becomes the same as or greater than the tick time, at
which point things degrade rather quickly.
This patch fixes bug 9906, "Weird hang with NPTL and SIGPROF."
Code Changes
This rework corrects the implementation of run_posix_cpu_timers() to make it
run in constant time for a particular machine. (Performance may vary between
one machine and another depending upon whether the kernel is built as single-
or multiprocessor and, in the latter case, depending upon the number of
running processors.) To do this, at each tick we now update fields in
signal_struct as well as task_struct. The run_posix_cpu_timers() function
uses those fields to make its decisions.
We define a new structure, "task_cputime," to contain user, system and
scheduler times and use these in appropriate places:
struct task_cputime {
cputime_t utime;
cputime_t stime;
unsigned long long sum_exec_runtime;
};
This is included in the structure "thread_group_cputime," which is a new
substructure of signal_struct and which varies for uniprocessor versus
multiprocessor kernels. For uniprocessor kernels, it uses "task_cputime" as
a simple substructure, while for multiprocessor kernels it is a pointer:
struct thread_group_cputime {
struct task_cputime totals;
};
struct thread_group_cputime {
struct task_cputime *totals;
};
We also add a new task_cputime substructure directly to signal_struct, to
cache the earliest expiration of process-wide timers, and task_cputime also
replaces the it_*_expires fields of task_struct (used for earliest expiration
of thread timers). The "thread_group_cputime" structure contains process-wide
timers that are updated via account_user_time() and friends. In the non-SMP
case the structure is a simple aggregator; unfortunately in the SMP case that
simplicity was not achievable due to cache-line contention between CPUs (in
one measured case performance was actually _worse_ on a 16-cpu system than
the same test on a 4-cpu system, due to this contention). For SMP, the
thread_group_cputime counters are maintained as a per-cpu structure allocated
using alloc_percpu(). The timer functions update only the timer field in
the structure corresponding to the running CPU, obtained using per_cpu_ptr().
We define a set of inline functions in sched.h that we use to maintain the
thread_group_cputime structure and hide the differences between UP and SMP
implementations from the rest of the kernel. The thread_group_cputime_init()
function initializes the thread_group_cputime structure for the given task.
The thread_group_cputime_alloc() is a no-op for UP; for SMP it calls the
out-of-line function thread_group_cputime_alloc_smp() to allocate and fill
in the per-cpu structures and fields. The thread_group_cputime_free()
function, also a no-op for UP, in SMP frees the per-cpu structures. The
thread_group_cputime_clone_thread() function (also a UP no-op) for SMP calls
thread_group_cputime_alloc() if the per-cpu structures haven't yet been
allocated. The thread_group_cputime() function fills the task_cputime
structure it is passed with the contents of the thread_group_cputime fields;
in UP it's that simple but in SMP it must also safely check that tsk->signal
is non-NULL (if it is it just uses the appropriate fields of task_struct) and,
if so, sums the per-cpu values for each online CPU. Finally, the three
functions account_group_user_time(), account_group_system_time() and
account_group_exec_runtime() are used by timer functions to update the
respective fields of the thread_group_cputime structure.
Non-SMP operation is trivial and will not be mentioned further.
The per-cpu structure is always allocated when a task creates its first new
thread, via a call to thread_group_cputime_clone_thread() from copy_signal().
It is freed at process exit via a call to thread_group_cputime_free() from
cleanup_signal().
All functions that formerly summed utime/stime/sum_sched_runtime values from
from all threads in the thread group now use thread_group_cputime() to
snapshot the values in the thread_group_cputime structure or the values in
the task structure itself if the per-cpu structure hasn't been allocated.
Finally, the code in kernel/posix-cpu-timers.c has changed quite a bit.
The run_posix_cpu_timers() function has been split into a fast path and a
slow path; the former safely checks whether there are any expired thread
timers and, if not, just returns, while the slow path does the heavy lifting.
With the dedicated thread group fields, timers are no longer "rebalanced" and
the process_timer_rebalance() function and related code has gone away. All
summing loops are gone and all code that used them now uses the
thread_group_cputime() inline. When process-wide timers are set, the new
task_cputime structure in signal_struct is used to cache the earliest
expiration; this is checked in the fast path.
Performance
The fix appears not to add significant overhead to existing operations. It
generally performs the same as the current code except in two cases, one in
which it performs slightly worse (Case 5 below) and one in which it performs
very significantly better (Case 2 below). Overall it's a wash except in those
two cases.
I've since done somewhat more involved testing on a dual-core Opteron system.
Case 1: With no itimer running, for a test with 100,000 threads, the fixed
kernel took 1428.5 seconds, 513 seconds more than the unfixed system,
all of which was spent in the system. There were twice as many
voluntary context switches with the fix as without it.
Case 2: With an itimer running at .01 second ticks and 4000 threads (the most
an unmodified kernel can handle), the fixed kernel ran the test in
eight percent of the time (5.8 seconds as opposed to 70 seconds) and
had better tick accuracy (.012 seconds per tick as opposed to .023
seconds per tick).
Case 3: A 4000-thread test with an initial timer tick of .01 second and an
interval of 10,000 seconds (i.e. a timer that ticks only once) had
very nearly the same performance in both cases: 6.3 seconds elapsed
for the fixed kernel versus 5.5 seconds for the unfixed kernel.
With fewer threads (eight in these tests), the Case 1 test ran in essentially
the same time on both the modified and unmodified kernels (5.2 seconds versus
5.8 seconds). The Case 2 test ran in about the same time as well, 5.9 seconds
versus 5.4 seconds but again with much better tick accuracy, .013 seconds per
tick versus .025 seconds per tick for the unmodified kernel.
Since the fix affected the rlimit code, I also tested soft and hard CPU limits.
Case 4: With a hard CPU limit of 20 seconds and eight threads (and an itimer
running), the modified kernel was very slightly favored in that while
it killed the process in 19.997 seconds of CPU time (5.002 seconds of
wall time), only .003 seconds of that was system time, the rest was
user time. The unmodified kernel killed the process in 20.001 seconds
of CPU (5.014 seconds of wall time) of which .016 seconds was system
time. Really, though, the results were too close to call. The results
were essentially the same with no itimer running.
Case 5: With a soft limit of 20 seconds and a hard limit of 2000 seconds
(where the hard limit would never be reached) and an itimer running,
the modified kernel exhibited worse tick accuracy than the unmodified
kernel: .050 seconds/tick versus .028 seconds/tick. Otherwise,
performance was almost indistinguishable. With no itimer running this
test exhibited virtually identical behavior and times in both cases.
In times past I did some limited performance testing. those results are below.
On a four-cpu Opteron system without this fix, a sixteen-thread test executed
in 3569.991 seconds, of which user was 3568.435s and system was 1.556s. On
the same system with the fix, user and elapsed time were about the same, but
system time dropped to 0.007 seconds. Performance with eight, four and one
thread were comparable. Interestingly, the timer ticks with the fix seemed
more accurate: The sixteen-thread test with the fix received 149543 ticks
for 0.024 seconds per tick, while the same test without the fix received 58720
for 0.061 seconds per tick. Both cases were configured for an interval of
0.01 seconds. Again, the other tests were comparable. Each thread in this
test computed the primes up to 25,000,000.
I also did a test with a large number of threads, 100,000 threads, which is
impossible without the fix. In this case each thread computed the primes only
up to 10,000 (to make the runtime manageable). System time dominated, at
1546.968 seconds out of a total 2176.906 seconds (giving a user time of
629.938s). It received 147651 ticks for 0.015 seconds per tick, still quite
accurate. There is obviously no comparable test without the fix.
Signed-off-by: Frank Mayhar <fmayhar@google.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-12 23:54:39 +07:00
|
|
|
* @p in case that task is currently running.
|
2009-03-31 14:56:03 +07:00
|
|
|
*
|
|
|
|
* Called with task_rq_lock() held on @rq.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-03-31 14:56:03 +07:00
|
|
|
static u64 do_task_delta_exec(struct task_struct *p, struct rq *rq)
|
|
|
|
{
|
|
|
|
u64 ns = 0;
|
|
|
|
|
|
|
|
if (task_current(rq, p)) {
|
|
|
|
update_rq_clock(rq);
|
|
|
|
ns = rq->clock - p->se.exec_start;
|
|
|
|
if ((s64)ns < 0)
|
|
|
|
ns = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ns;
|
|
|
|
}
|
|
|
|
|
2008-09-12 23:54:39 +07:00
|
|
|
unsigned long long task_delta_exec(struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-07-09 23:51:58 +07:00
|
|
|
struct rq *rq;
|
2008-09-12 23:54:39 +07:00
|
|
|
u64 ns = 0;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2007-07-09 23:51:58 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
2009-03-31 14:56:03 +07:00
|
|
|
ns = do_task_delta_exec(p, rq);
|
|
|
|
task_rq_unlock(rq, &flags);
|
2008-09-30 13:28:17 +07:00
|
|
|
|
2009-03-31 14:56:03 +07:00
|
|
|
return ns;
|
|
|
|
}
|
timers: fix itimer/many thread hang
Overview
This patch reworks the handling of POSIX CPU timers, including the
ITIMER_PROF, ITIMER_VIRT timers and rlimit handling. It was put together
with the help of Roland McGrath, the owner and original writer of this code.
The problem we ran into, and the reason for this rework, has to do with using
a profiling timer in a process with a large number of threads. It appears
that the performance of the old implementation of run_posix_cpu_timers() was
at least O(n*3) (where "n" is the number of threads in a process) or worse.
Everything is fine with an increasing number of threads until the time taken
for that routine to run becomes the same as or greater than the tick time, at
which point things degrade rather quickly.
This patch fixes bug 9906, "Weird hang with NPTL and SIGPROF."
Code Changes
This rework corrects the implementation of run_posix_cpu_timers() to make it
run in constant time for a particular machine. (Performance may vary between
one machine and another depending upon whether the kernel is built as single-
or multiprocessor and, in the latter case, depending upon the number of
running processors.) To do this, at each tick we now update fields in
signal_struct as well as task_struct. The run_posix_cpu_timers() function
uses those fields to make its decisions.
We define a new structure, "task_cputime," to contain user, system and
scheduler times and use these in appropriate places:
struct task_cputime {
cputime_t utime;
cputime_t stime;
unsigned long long sum_exec_runtime;
};
This is included in the structure "thread_group_cputime," which is a new
substructure of signal_struct and which varies for uniprocessor versus
multiprocessor kernels. For uniprocessor kernels, it uses "task_cputime" as
a simple substructure, while for multiprocessor kernels it is a pointer:
struct thread_group_cputime {
struct task_cputime totals;
};
struct thread_group_cputime {
struct task_cputime *totals;
};
We also add a new task_cputime substructure directly to signal_struct, to
cache the earliest expiration of process-wide timers, and task_cputime also
replaces the it_*_expires fields of task_struct (used for earliest expiration
of thread timers). The "thread_group_cputime" structure contains process-wide
timers that are updated via account_user_time() and friends. In the non-SMP
case the structure is a simple aggregator; unfortunately in the SMP case that
simplicity was not achievable due to cache-line contention between CPUs (in
one measured case performance was actually _worse_ on a 16-cpu system than
the same test on a 4-cpu system, due to this contention). For SMP, the
thread_group_cputime counters are maintained as a per-cpu structure allocated
using alloc_percpu(). The timer functions update only the timer field in
the structure corresponding to the running CPU, obtained using per_cpu_ptr().
We define a set of inline functions in sched.h that we use to maintain the
thread_group_cputime structure and hide the differences between UP and SMP
implementations from the rest of the kernel. The thread_group_cputime_init()
function initializes the thread_group_cputime structure for the given task.
The thread_group_cputime_alloc() is a no-op for UP; for SMP it calls the
out-of-line function thread_group_cputime_alloc_smp() to allocate and fill
in the per-cpu structures and fields. The thread_group_cputime_free()
function, also a no-op for UP, in SMP frees the per-cpu structures. The
thread_group_cputime_clone_thread() function (also a UP no-op) for SMP calls
thread_group_cputime_alloc() if the per-cpu structures haven't yet been
allocated. The thread_group_cputime() function fills the task_cputime
structure it is passed with the contents of the thread_group_cputime fields;
in UP it's that simple but in SMP it must also safely check that tsk->signal
is non-NULL (if it is it just uses the appropriate fields of task_struct) and,
if so, sums the per-cpu values for each online CPU. Finally, the three
functions account_group_user_time(), account_group_system_time() and
account_group_exec_runtime() are used by timer functions to update the
respective fields of the thread_group_cputime structure.
Non-SMP operation is trivial and will not be mentioned further.
The per-cpu structure is always allocated when a task creates its first new
thread, via a call to thread_group_cputime_clone_thread() from copy_signal().
It is freed at process exit via a call to thread_group_cputime_free() from
cleanup_signal().
All functions that formerly summed utime/stime/sum_sched_runtime values from
from all threads in the thread group now use thread_group_cputime() to
snapshot the values in the thread_group_cputime structure or the values in
the task structure itself if the per-cpu structure hasn't been allocated.
Finally, the code in kernel/posix-cpu-timers.c has changed quite a bit.
The run_posix_cpu_timers() function has been split into a fast path and a
slow path; the former safely checks whether there are any expired thread
timers and, if not, just returns, while the slow path does the heavy lifting.
With the dedicated thread group fields, timers are no longer "rebalanced" and
the process_timer_rebalance() function and related code has gone away. All
summing loops are gone and all code that used them now uses the
thread_group_cputime() inline. When process-wide timers are set, the new
task_cputime structure in signal_struct is used to cache the earliest
expiration; this is checked in the fast path.
Performance
The fix appears not to add significant overhead to existing operations. It
generally performs the same as the current code except in two cases, one in
which it performs slightly worse (Case 5 below) and one in which it performs
very significantly better (Case 2 below). Overall it's a wash except in those
two cases.
I've since done somewhat more involved testing on a dual-core Opteron system.
Case 1: With no itimer running, for a test with 100,000 threads, the fixed
kernel took 1428.5 seconds, 513 seconds more than the unfixed system,
all of which was spent in the system. There were twice as many
voluntary context switches with the fix as without it.
Case 2: With an itimer running at .01 second ticks and 4000 threads (the most
an unmodified kernel can handle), the fixed kernel ran the test in
eight percent of the time (5.8 seconds as opposed to 70 seconds) and
had better tick accuracy (.012 seconds per tick as opposed to .023
seconds per tick).
Case 3: A 4000-thread test with an initial timer tick of .01 second and an
interval of 10,000 seconds (i.e. a timer that ticks only once) had
very nearly the same performance in both cases: 6.3 seconds elapsed
for the fixed kernel versus 5.5 seconds for the unfixed kernel.
With fewer threads (eight in these tests), the Case 1 test ran in essentially
the same time on both the modified and unmodified kernels (5.2 seconds versus
5.8 seconds). The Case 2 test ran in about the same time as well, 5.9 seconds
versus 5.4 seconds but again with much better tick accuracy, .013 seconds per
tick versus .025 seconds per tick for the unmodified kernel.
Since the fix affected the rlimit code, I also tested soft and hard CPU limits.
Case 4: With a hard CPU limit of 20 seconds and eight threads (and an itimer
running), the modified kernel was very slightly favored in that while
it killed the process in 19.997 seconds of CPU time (5.002 seconds of
wall time), only .003 seconds of that was system time, the rest was
user time. The unmodified kernel killed the process in 20.001 seconds
of CPU (5.014 seconds of wall time) of which .016 seconds was system
time. Really, though, the results were too close to call. The results
were essentially the same with no itimer running.
Case 5: With a soft limit of 20 seconds and a hard limit of 2000 seconds
(where the hard limit would never be reached) and an itimer running,
the modified kernel exhibited worse tick accuracy than the unmodified
kernel: .050 seconds/tick versus .028 seconds/tick. Otherwise,
performance was almost indistinguishable. With no itimer running this
test exhibited virtually identical behavior and times in both cases.
In times past I did some limited performance testing. those results are below.
On a four-cpu Opteron system without this fix, a sixteen-thread test executed
in 3569.991 seconds, of which user was 3568.435s and system was 1.556s. On
the same system with the fix, user and elapsed time were about the same, but
system time dropped to 0.007 seconds. Performance with eight, four and one
thread were comparable. Interestingly, the timer ticks with the fix seemed
more accurate: The sixteen-thread test with the fix received 149543 ticks
for 0.024 seconds per tick, while the same test without the fix received 58720
for 0.061 seconds per tick. Both cases were configured for an interval of
0.01 seconds. Again, the other tests were comparable. Each thread in this
test computed the primes up to 25,000,000.
I also did a test with a large number of threads, 100,000 threads, which is
impossible without the fix. In this case each thread computed the primes only
up to 10,000 (to make the runtime manageable). System time dominated, at
1546.968 seconds out of a total 2176.906 seconds (giving a user time of
629.938s). It received 147651 ticks for 0.015 seconds per tick, still quite
accurate. There is obviously no comparable test without the fix.
Signed-off-by: Frank Mayhar <fmayhar@google.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-12 23:54:39 +07:00
|
|
|
|
2009-03-31 14:56:03 +07:00
|
|
|
/*
|
|
|
|
* Return accounted runtime for the task.
|
|
|
|
* In case the task is currently running, return the runtime plus current's
|
|
|
|
* pending runtime that have not been accounted yet.
|
|
|
|
*/
|
|
|
|
unsigned long long task_sched_runtime(struct task_struct *p)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct rq *rq;
|
|
|
|
u64 ns = 0;
|
|
|
|
|
|
|
|
rq = task_rq_lock(p, &flags);
|
|
|
|
ns = p->se.sum_exec_runtime + do_task_delta_exec(p, rq);
|
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
|
|
|
|
return ns;
|
|
|
|
}
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2009-03-31 14:56:03 +07:00
|
|
|
/*
|
|
|
|
* Return sum_exec_runtime for the thread group.
|
|
|
|
* In case the task is currently running, return the sum plus current's
|
|
|
|
* pending runtime that have not been accounted yet.
|
|
|
|
*
|
|
|
|
* Note that the thread group might have other running tasks as well,
|
|
|
|
* so the return value not includes other pending runtime that other
|
|
|
|
* running tasks might have.
|
|
|
|
*/
|
|
|
|
unsigned long long thread_group_sched_runtime(struct task_struct *p)
|
|
|
|
{
|
|
|
|
struct task_cputime totals;
|
|
|
|
unsigned long flags;
|
|
|
|
struct rq *rq;
|
|
|
|
u64 ns;
|
|
|
|
|
|
|
|
rq = task_rq_lock(p, &flags);
|
|
|
|
thread_group_cputime(p, &totals);
|
|
|
|
ns = totals.sum_exec_runtime + do_task_delta_exec(p, rq);
|
2007-07-09 23:51:58 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return ns;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Account user cpu time to a process.
|
|
|
|
* @p: the process that the cpu time gets accounted to
|
|
|
|
* @cputime: the cpu time spent in user space since the last update
|
2008-12-31 21:11:37 +07:00
|
|
|
* @cputime_scaled: cputime scaled by cpu frequency
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-12-31 21:11:37 +07:00
|
|
|
void account_user_time(struct task_struct *p, cputime_t cputime,
|
|
|
|
cputime_t cputime_scaled)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
|
|
|
|
cputime64_t tmp;
|
|
|
|
|
2008-12-31 21:11:37 +07:00
|
|
|
/* Add user time to process. */
|
2005-04-17 05:20:36 +07:00
|
|
|
p->utime = cputime_add(p->utime, cputime);
|
2008-12-31 21:11:37 +07:00
|
|
|
p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
|
timers: fix itimer/many thread hang
Overview
This patch reworks the handling of POSIX CPU timers, including the
ITIMER_PROF, ITIMER_VIRT timers and rlimit handling. It was put together
with the help of Roland McGrath, the owner and original writer of this code.
The problem we ran into, and the reason for this rework, has to do with using
a profiling timer in a process with a large number of threads. It appears
that the performance of the old implementation of run_posix_cpu_timers() was
at least O(n*3) (where "n" is the number of threads in a process) or worse.
Everything is fine with an increasing number of threads until the time taken
for that routine to run becomes the same as or greater than the tick time, at
which point things degrade rather quickly.
This patch fixes bug 9906, "Weird hang with NPTL and SIGPROF."
Code Changes
This rework corrects the implementation of run_posix_cpu_timers() to make it
run in constant time for a particular machine. (Performance may vary between
one machine and another depending upon whether the kernel is built as single-
or multiprocessor and, in the latter case, depending upon the number of
running processors.) To do this, at each tick we now update fields in
signal_struct as well as task_struct. The run_posix_cpu_timers() function
uses those fields to make its decisions.
We define a new structure, "task_cputime," to contain user, system and
scheduler times and use these in appropriate places:
struct task_cputime {
cputime_t utime;
cputime_t stime;
unsigned long long sum_exec_runtime;
};
This is included in the structure "thread_group_cputime," which is a new
substructure of signal_struct and which varies for uniprocessor versus
multiprocessor kernels. For uniprocessor kernels, it uses "task_cputime" as
a simple substructure, while for multiprocessor kernels it is a pointer:
struct thread_group_cputime {
struct task_cputime totals;
};
struct thread_group_cputime {
struct task_cputime *totals;
};
We also add a new task_cputime substructure directly to signal_struct, to
cache the earliest expiration of process-wide timers, and task_cputime also
replaces the it_*_expires fields of task_struct (used for earliest expiration
of thread timers). The "thread_group_cputime" structure contains process-wide
timers that are updated via account_user_time() and friends. In the non-SMP
case the structure is a simple aggregator; unfortunately in the SMP case that
simplicity was not achievable due to cache-line contention between CPUs (in
one measured case performance was actually _worse_ on a 16-cpu system than
the same test on a 4-cpu system, due to this contention). For SMP, the
thread_group_cputime counters are maintained as a per-cpu structure allocated
using alloc_percpu(). The timer functions update only the timer field in
the structure corresponding to the running CPU, obtained using per_cpu_ptr().
We define a set of inline functions in sched.h that we use to maintain the
thread_group_cputime structure and hide the differences between UP and SMP
implementations from the rest of the kernel. The thread_group_cputime_init()
function initializes the thread_group_cputime structure for the given task.
The thread_group_cputime_alloc() is a no-op for UP; for SMP it calls the
out-of-line function thread_group_cputime_alloc_smp() to allocate and fill
in the per-cpu structures and fields. The thread_group_cputime_free()
function, also a no-op for UP, in SMP frees the per-cpu structures. The
thread_group_cputime_clone_thread() function (also a UP no-op) for SMP calls
thread_group_cputime_alloc() if the per-cpu structures haven't yet been
allocated. The thread_group_cputime() function fills the task_cputime
structure it is passed with the contents of the thread_group_cputime fields;
in UP it's that simple but in SMP it must also safely check that tsk->signal
is non-NULL (if it is it just uses the appropriate fields of task_struct) and,
if so, sums the per-cpu values for each online CPU. Finally, the three
functions account_group_user_time(), account_group_system_time() and
account_group_exec_runtime() are used by timer functions to update the
respective fields of the thread_group_cputime structure.
Non-SMP operation is trivial and will not be mentioned further.
The per-cpu structure is always allocated when a task creates its first new
thread, via a call to thread_group_cputime_clone_thread() from copy_signal().
It is freed at process exit via a call to thread_group_cputime_free() from
cleanup_signal().
All functions that formerly summed utime/stime/sum_sched_runtime values from
from all threads in the thread group now use thread_group_cputime() to
snapshot the values in the thread_group_cputime structure or the values in
the task structure itself if the per-cpu structure hasn't been allocated.
Finally, the code in kernel/posix-cpu-timers.c has changed quite a bit.
The run_posix_cpu_timers() function has been split into a fast path and a
slow path; the former safely checks whether there are any expired thread
timers and, if not, just returns, while the slow path does the heavy lifting.
With the dedicated thread group fields, timers are no longer "rebalanced" and
the process_timer_rebalance() function and related code has gone away. All
summing loops are gone and all code that used them now uses the
thread_group_cputime() inline. When process-wide timers are set, the new
task_cputime structure in signal_struct is used to cache the earliest
expiration; this is checked in the fast path.
Performance
The fix appears not to add significant overhead to existing operations. It
generally performs the same as the current code except in two cases, one in
which it performs slightly worse (Case 5 below) and one in which it performs
very significantly better (Case 2 below). Overall it's a wash except in those
two cases.
I've since done somewhat more involved testing on a dual-core Opteron system.
Case 1: With no itimer running, for a test with 100,000 threads, the fixed
kernel took 1428.5 seconds, 513 seconds more than the unfixed system,
all of which was spent in the system. There were twice as many
voluntary context switches with the fix as without it.
Case 2: With an itimer running at .01 second ticks and 4000 threads (the most
an unmodified kernel can handle), the fixed kernel ran the test in
eight percent of the time (5.8 seconds as opposed to 70 seconds) and
had better tick accuracy (.012 seconds per tick as opposed to .023
seconds per tick).
Case 3: A 4000-thread test with an initial timer tick of .01 second and an
interval of 10,000 seconds (i.e. a timer that ticks only once) had
very nearly the same performance in both cases: 6.3 seconds elapsed
for the fixed kernel versus 5.5 seconds for the unfixed kernel.
With fewer threads (eight in these tests), the Case 1 test ran in essentially
the same time on both the modified and unmodified kernels (5.2 seconds versus
5.8 seconds). The Case 2 test ran in about the same time as well, 5.9 seconds
versus 5.4 seconds but again with much better tick accuracy, .013 seconds per
tick versus .025 seconds per tick for the unmodified kernel.
Since the fix affected the rlimit code, I also tested soft and hard CPU limits.
Case 4: With a hard CPU limit of 20 seconds and eight threads (and an itimer
running), the modified kernel was very slightly favored in that while
it killed the process in 19.997 seconds of CPU time (5.002 seconds of
wall time), only .003 seconds of that was system time, the rest was
user time. The unmodified kernel killed the process in 20.001 seconds
of CPU (5.014 seconds of wall time) of which .016 seconds was system
time. Really, though, the results were too close to call. The results
were essentially the same with no itimer running.
Case 5: With a soft limit of 20 seconds and a hard limit of 2000 seconds
(where the hard limit would never be reached) and an itimer running,
the modified kernel exhibited worse tick accuracy than the unmodified
kernel: .050 seconds/tick versus .028 seconds/tick. Otherwise,
performance was almost indistinguishable. With no itimer running this
test exhibited virtually identical behavior and times in both cases.
In times past I did some limited performance testing. those results are below.
On a four-cpu Opteron system without this fix, a sixteen-thread test executed
in 3569.991 seconds, of which user was 3568.435s and system was 1.556s. On
the same system with the fix, user and elapsed time were about the same, but
system time dropped to 0.007 seconds. Performance with eight, four and one
thread were comparable. Interestingly, the timer ticks with the fix seemed
more accurate: The sixteen-thread test with the fix received 149543 ticks
for 0.024 seconds per tick, while the same test without the fix received 58720
for 0.061 seconds per tick. Both cases were configured for an interval of
0.01 seconds. Again, the other tests were comparable. Each thread in this
test computed the primes up to 25,000,000.
I also did a test with a large number of threads, 100,000 threads, which is
impossible without the fix. In this case each thread computed the primes only
up to 10,000 (to make the runtime manageable). System time dominated, at
1546.968 seconds out of a total 2176.906 seconds (giving a user time of
629.938s). It received 147651 ticks for 0.015 seconds per tick, still quite
accurate. There is obviously no comparable test without the fix.
Signed-off-by: Frank Mayhar <fmayhar@google.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-12 23:54:39 +07:00
|
|
|
account_group_user_time(p, cputime);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Add user time to cpustat. */
|
|
|
|
tmp = cputime_to_cputime64(cputime);
|
|
|
|
if (TASK_NICE(p) > 0)
|
|
|
|
cpustat->nice = cputime64_add(cpustat->nice, tmp);
|
|
|
|
else
|
|
|
|
cpustat->user = cputime64_add(cpustat->user, tmp);
|
2009-03-31 11:32:22 +07:00
|
|
|
|
|
|
|
cpuacct_update_stats(p, CPUACCT_STAT_USER, cputime);
|
2008-07-25 15:48:40 +07:00
|
|
|
/* Account for user time used */
|
|
|
|
acct_update_integrals(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:19 +07:00
|
|
|
/*
|
|
|
|
* Account guest cpu time to a process.
|
|
|
|
* @p: the process that the cpu time gets accounted to
|
|
|
|
* @cputime: the cpu time spent in virtual machine since the last update
|
2008-12-31 21:11:37 +07:00
|
|
|
* @cputime_scaled: cputime scaled by cpu frequency
|
2007-10-15 22:00:19 +07:00
|
|
|
*/
|
2008-12-31 21:11:37 +07:00
|
|
|
static void account_guest_time(struct task_struct *p, cputime_t cputime,
|
|
|
|
cputime_t cputime_scaled)
|
2007-10-15 22:00:19 +07:00
|
|
|
{
|
|
|
|
cputime64_t tmp;
|
|
|
|
struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
|
|
|
|
|
|
|
|
tmp = cputime_to_cputime64(cputime);
|
|
|
|
|
2008-12-31 21:11:37 +07:00
|
|
|
/* Add guest time to process. */
|
2007-10-15 22:00:19 +07:00
|
|
|
p->utime = cputime_add(p->utime, cputime);
|
2008-12-31 21:11:37 +07:00
|
|
|
p->utimescaled = cputime_add(p->utimescaled, cputime_scaled);
|
timers: fix itimer/many thread hang
Overview
This patch reworks the handling of POSIX CPU timers, including the
ITIMER_PROF, ITIMER_VIRT timers and rlimit handling. It was put together
with the help of Roland McGrath, the owner and original writer of this code.
The problem we ran into, and the reason for this rework, has to do with using
a profiling timer in a process with a large number of threads. It appears
that the performance of the old implementation of run_posix_cpu_timers() was
at least O(n*3) (where "n" is the number of threads in a process) or worse.
Everything is fine with an increasing number of threads until the time taken
for that routine to run becomes the same as or greater than the tick time, at
which point things degrade rather quickly.
This patch fixes bug 9906, "Weird hang with NPTL and SIGPROF."
Code Changes
This rework corrects the implementation of run_posix_cpu_timers() to make it
run in constant time for a particular machine. (Performance may vary between
one machine and another depending upon whether the kernel is built as single-
or multiprocessor and, in the latter case, depending upon the number of
running processors.) To do this, at each tick we now update fields in
signal_struct as well as task_struct. The run_posix_cpu_timers() function
uses those fields to make its decisions.
We define a new structure, "task_cputime," to contain user, system and
scheduler times and use these in appropriate places:
struct task_cputime {
cputime_t utime;
cputime_t stime;
unsigned long long sum_exec_runtime;
};
This is included in the structure "thread_group_cputime," which is a new
substructure of signal_struct and which varies for uniprocessor versus
multiprocessor kernels. For uniprocessor kernels, it uses "task_cputime" as
a simple substructure, while for multiprocessor kernels it is a pointer:
struct thread_group_cputime {
struct task_cputime totals;
};
struct thread_group_cputime {
struct task_cputime *totals;
};
We also add a new task_cputime substructure directly to signal_struct, to
cache the earliest expiration of process-wide timers, and task_cputime also
replaces the it_*_expires fields of task_struct (used for earliest expiration
of thread timers). The "thread_group_cputime" structure contains process-wide
timers that are updated via account_user_time() and friends. In the non-SMP
case the structure is a simple aggregator; unfortunately in the SMP case that
simplicity was not achievable due to cache-line contention between CPUs (in
one measured case performance was actually _worse_ on a 16-cpu system than
the same test on a 4-cpu system, due to this contention). For SMP, the
thread_group_cputime counters are maintained as a per-cpu structure allocated
using alloc_percpu(). The timer functions update only the timer field in
the structure corresponding to the running CPU, obtained using per_cpu_ptr().
We define a set of inline functions in sched.h that we use to maintain the
thread_group_cputime structure and hide the differences between UP and SMP
implementations from the rest of the kernel. The thread_group_cputime_init()
function initializes the thread_group_cputime structure for the given task.
The thread_group_cputime_alloc() is a no-op for UP; for SMP it calls the
out-of-line function thread_group_cputime_alloc_smp() to allocate and fill
in the per-cpu structures and fields. The thread_group_cputime_free()
function, also a no-op for UP, in SMP frees the per-cpu structures. The
thread_group_cputime_clone_thread() function (also a UP no-op) for SMP calls
thread_group_cputime_alloc() if the per-cpu structures haven't yet been
allocated. The thread_group_cputime() function fills the task_cputime
structure it is passed with the contents of the thread_group_cputime fields;
in UP it's that simple but in SMP it must also safely check that tsk->signal
is non-NULL (if it is it just uses the appropriate fields of task_struct) and,
if so, sums the per-cpu values for each online CPU. Finally, the three
functions account_group_user_time(), account_group_system_time() and
account_group_exec_runtime() are used by timer functions to update the
respective fields of the thread_group_cputime structure.
Non-SMP operation is trivial and will not be mentioned further.
The per-cpu structure is always allocated when a task creates its first new
thread, via a call to thread_group_cputime_clone_thread() from copy_signal().
It is freed at process exit via a call to thread_group_cputime_free() from
cleanup_signal().
All functions that formerly summed utime/stime/sum_sched_runtime values from
from all threads in the thread group now use thread_group_cputime() to
snapshot the values in the thread_group_cputime structure or the values in
the task structure itself if the per-cpu structure hasn't been allocated.
Finally, the code in kernel/posix-cpu-timers.c has changed quite a bit.
The run_posix_cpu_timers() function has been split into a fast path and a
slow path; the former safely checks whether there are any expired thread
timers and, if not, just returns, while the slow path does the heavy lifting.
With the dedicated thread group fields, timers are no longer "rebalanced" and
the process_timer_rebalance() function and related code has gone away. All
summing loops are gone and all code that used them now uses the
thread_group_cputime() inline. When process-wide timers are set, the new
task_cputime structure in signal_struct is used to cache the earliest
expiration; this is checked in the fast path.
Performance
The fix appears not to add significant overhead to existing operations. It
generally performs the same as the current code except in two cases, one in
which it performs slightly worse (Case 5 below) and one in which it performs
very significantly better (Case 2 below). Overall it's a wash except in those
two cases.
I've since done somewhat more involved testing on a dual-core Opteron system.
Case 1: With no itimer running, for a test with 100,000 threads, the fixed
kernel took 1428.5 seconds, 513 seconds more than the unfixed system,
all of which was spent in the system. There were twice as many
voluntary context switches with the fix as without it.
Case 2: With an itimer running at .01 second ticks and 4000 threads (the most
an unmodified kernel can handle), the fixed kernel ran the test in
eight percent of the time (5.8 seconds as opposed to 70 seconds) and
had better tick accuracy (.012 seconds per tick as opposed to .023
seconds per tick).
Case 3: A 4000-thread test with an initial timer tick of .01 second and an
interval of 10,000 seconds (i.e. a timer that ticks only once) had
very nearly the same performance in both cases: 6.3 seconds elapsed
for the fixed kernel versus 5.5 seconds for the unfixed kernel.
With fewer threads (eight in these tests), the Case 1 test ran in essentially
the same time on both the modified and unmodified kernels (5.2 seconds versus
5.8 seconds). The Case 2 test ran in about the same time as well, 5.9 seconds
versus 5.4 seconds but again with much better tick accuracy, .013 seconds per
tick versus .025 seconds per tick for the unmodified kernel.
Since the fix affected the rlimit code, I also tested soft and hard CPU limits.
Case 4: With a hard CPU limit of 20 seconds and eight threads (and an itimer
running), the modified kernel was very slightly favored in that while
it killed the process in 19.997 seconds of CPU time (5.002 seconds of
wall time), only .003 seconds of that was system time, the rest was
user time. The unmodified kernel killed the process in 20.001 seconds
of CPU (5.014 seconds of wall time) of which .016 seconds was system
time. Really, though, the results were too close to call. The results
were essentially the same with no itimer running.
Case 5: With a soft limit of 20 seconds and a hard limit of 2000 seconds
(where the hard limit would never be reached) and an itimer running,
the modified kernel exhibited worse tick accuracy than the unmodified
kernel: .050 seconds/tick versus .028 seconds/tick. Otherwise,
performance was almost indistinguishable. With no itimer running this
test exhibited virtually identical behavior and times in both cases.
In times past I did some limited performance testing. those results are below.
On a four-cpu Opteron system without this fix, a sixteen-thread test executed
in 3569.991 seconds, of which user was 3568.435s and system was 1.556s. On
the same system with the fix, user and elapsed time were about the same, but
system time dropped to 0.007 seconds. Performance with eight, four and one
thread were comparable. Interestingly, the timer ticks with the fix seemed
more accurate: The sixteen-thread test with the fix received 149543 ticks
for 0.024 seconds per tick, while the same test without the fix received 58720
for 0.061 seconds per tick. Both cases were configured for an interval of
0.01 seconds. Again, the other tests were comparable. Each thread in this
test computed the primes up to 25,000,000.
I also did a test with a large number of threads, 100,000 threads, which is
impossible without the fix. In this case each thread computed the primes only
up to 10,000 (to make the runtime manageable). System time dominated, at
1546.968 seconds out of a total 2176.906 seconds (giving a user time of
629.938s). It received 147651 ticks for 0.015 seconds per tick, still quite
accurate. There is obviously no comparable test without the fix.
Signed-off-by: Frank Mayhar <fmayhar@google.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-12 23:54:39 +07:00
|
|
|
account_group_user_time(p, cputime);
|
2007-10-15 22:00:19 +07:00
|
|
|
p->gtime = cputime_add(p->gtime, cputime);
|
|
|
|
|
2008-12-31 21:11:37 +07:00
|
|
|
/* Add guest time to cpustat. */
|
2009-10-23 23:20:10 +07:00
|
|
|
if (TASK_NICE(p) > 0) {
|
|
|
|
cpustat->nice = cputime64_add(cpustat->nice, tmp);
|
|
|
|
cpustat->guest_nice = cputime64_add(cpustat->guest_nice, tmp);
|
|
|
|
} else {
|
|
|
|
cpustat->user = cputime64_add(cpustat->user, tmp);
|
|
|
|
cpustat->guest = cputime64_add(cpustat->guest, tmp);
|
|
|
|
}
|
2007-10-15 22:00:19 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Account system cpu time to a process.
|
|
|
|
* @p: the process that the cpu time gets accounted to
|
|
|
|
* @hardirq_offset: the offset to subtract from hardirq_count()
|
|
|
|
* @cputime: the cpu time spent in kernel space since the last update
|
2008-12-31 21:11:37 +07:00
|
|
|
* @cputime_scaled: cputime scaled by cpu frequency
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
void account_system_time(struct task_struct *p, int hardirq_offset,
|
2008-12-31 21:11:37 +07:00
|
|
|
cputime_t cputime, cputime_t cputime_scaled)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
|
|
|
|
cputime64_t tmp;
|
|
|
|
|
2008-04-25 08:17:55 +07:00
|
|
|
if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
|
2008-12-31 21:11:37 +07:00
|
|
|
account_guest_time(p, cputime, cputime_scaled);
|
2008-04-25 08:17:55 +07:00
|
|
|
return;
|
|
|
|
}
|
2007-10-15 22:00:19 +07:00
|
|
|
|
2008-12-31 21:11:37 +07:00
|
|
|
/* Add system time to process. */
|
2005-04-17 05:20:36 +07:00
|
|
|
p->stime = cputime_add(p->stime, cputime);
|
2008-12-31 21:11:37 +07:00
|
|
|
p->stimescaled = cputime_add(p->stimescaled, cputime_scaled);
|
timers: fix itimer/many thread hang
Overview
This patch reworks the handling of POSIX CPU timers, including the
ITIMER_PROF, ITIMER_VIRT timers and rlimit handling. It was put together
with the help of Roland McGrath, the owner and original writer of this code.
The problem we ran into, and the reason for this rework, has to do with using
a profiling timer in a process with a large number of threads. It appears
that the performance of the old implementation of run_posix_cpu_timers() was
at least O(n*3) (where "n" is the number of threads in a process) or worse.
Everything is fine with an increasing number of threads until the time taken
for that routine to run becomes the same as or greater than the tick time, at
which point things degrade rather quickly.
This patch fixes bug 9906, "Weird hang with NPTL and SIGPROF."
Code Changes
This rework corrects the implementation of run_posix_cpu_timers() to make it
run in constant time for a particular machine. (Performance may vary between
one machine and another depending upon whether the kernel is built as single-
or multiprocessor and, in the latter case, depending upon the number of
running processors.) To do this, at each tick we now update fields in
signal_struct as well as task_struct. The run_posix_cpu_timers() function
uses those fields to make its decisions.
We define a new structure, "task_cputime," to contain user, system and
scheduler times and use these in appropriate places:
struct task_cputime {
cputime_t utime;
cputime_t stime;
unsigned long long sum_exec_runtime;
};
This is included in the structure "thread_group_cputime," which is a new
substructure of signal_struct and which varies for uniprocessor versus
multiprocessor kernels. For uniprocessor kernels, it uses "task_cputime" as
a simple substructure, while for multiprocessor kernels it is a pointer:
struct thread_group_cputime {
struct task_cputime totals;
};
struct thread_group_cputime {
struct task_cputime *totals;
};
We also add a new task_cputime substructure directly to signal_struct, to
cache the earliest expiration of process-wide timers, and task_cputime also
replaces the it_*_expires fields of task_struct (used for earliest expiration
of thread timers). The "thread_group_cputime" structure contains process-wide
timers that are updated via account_user_time() and friends. In the non-SMP
case the structure is a simple aggregator; unfortunately in the SMP case that
simplicity was not achievable due to cache-line contention between CPUs (in
one measured case performance was actually _worse_ on a 16-cpu system than
the same test on a 4-cpu system, due to this contention). For SMP, the
thread_group_cputime counters are maintained as a per-cpu structure allocated
using alloc_percpu(). The timer functions update only the timer field in
the structure corresponding to the running CPU, obtained using per_cpu_ptr().
We define a set of inline functions in sched.h that we use to maintain the
thread_group_cputime structure and hide the differences between UP and SMP
implementations from the rest of the kernel. The thread_group_cputime_init()
function initializes the thread_group_cputime structure for the given task.
The thread_group_cputime_alloc() is a no-op for UP; for SMP it calls the
out-of-line function thread_group_cputime_alloc_smp() to allocate and fill
in the per-cpu structures and fields. The thread_group_cputime_free()
function, also a no-op for UP, in SMP frees the per-cpu structures. The
thread_group_cputime_clone_thread() function (also a UP no-op) for SMP calls
thread_group_cputime_alloc() if the per-cpu structures haven't yet been
allocated. The thread_group_cputime() function fills the task_cputime
structure it is passed with the contents of the thread_group_cputime fields;
in UP it's that simple but in SMP it must also safely check that tsk->signal
is non-NULL (if it is it just uses the appropriate fields of task_struct) and,
if so, sums the per-cpu values for each online CPU. Finally, the three
functions account_group_user_time(), account_group_system_time() and
account_group_exec_runtime() are used by timer functions to update the
respective fields of the thread_group_cputime structure.
Non-SMP operation is trivial and will not be mentioned further.
The per-cpu structure is always allocated when a task creates its first new
thread, via a call to thread_group_cputime_clone_thread() from copy_signal().
It is freed at process exit via a call to thread_group_cputime_free() from
cleanup_signal().
All functions that formerly summed utime/stime/sum_sched_runtime values from
from all threads in the thread group now use thread_group_cputime() to
snapshot the values in the thread_group_cputime structure or the values in
the task structure itself if the per-cpu structure hasn't been allocated.
Finally, the code in kernel/posix-cpu-timers.c has changed quite a bit.
The run_posix_cpu_timers() function has been split into a fast path and a
slow path; the former safely checks whether there are any expired thread
timers and, if not, just returns, while the slow path does the heavy lifting.
With the dedicated thread group fields, timers are no longer "rebalanced" and
the process_timer_rebalance() function and related code has gone away. All
summing loops are gone and all code that used them now uses the
thread_group_cputime() inline. When process-wide timers are set, the new
task_cputime structure in signal_struct is used to cache the earliest
expiration; this is checked in the fast path.
Performance
The fix appears not to add significant overhead to existing operations. It
generally performs the same as the current code except in two cases, one in
which it performs slightly worse (Case 5 below) and one in which it performs
very significantly better (Case 2 below). Overall it's a wash except in those
two cases.
I've since done somewhat more involved testing on a dual-core Opteron system.
Case 1: With no itimer running, for a test with 100,000 threads, the fixed
kernel took 1428.5 seconds, 513 seconds more than the unfixed system,
all of which was spent in the system. There were twice as many
voluntary context switches with the fix as without it.
Case 2: With an itimer running at .01 second ticks and 4000 threads (the most
an unmodified kernel can handle), the fixed kernel ran the test in
eight percent of the time (5.8 seconds as opposed to 70 seconds) and
had better tick accuracy (.012 seconds per tick as opposed to .023
seconds per tick).
Case 3: A 4000-thread test with an initial timer tick of .01 second and an
interval of 10,000 seconds (i.e. a timer that ticks only once) had
very nearly the same performance in both cases: 6.3 seconds elapsed
for the fixed kernel versus 5.5 seconds for the unfixed kernel.
With fewer threads (eight in these tests), the Case 1 test ran in essentially
the same time on both the modified and unmodified kernels (5.2 seconds versus
5.8 seconds). The Case 2 test ran in about the same time as well, 5.9 seconds
versus 5.4 seconds but again with much better tick accuracy, .013 seconds per
tick versus .025 seconds per tick for the unmodified kernel.
Since the fix affected the rlimit code, I also tested soft and hard CPU limits.
Case 4: With a hard CPU limit of 20 seconds and eight threads (and an itimer
running), the modified kernel was very slightly favored in that while
it killed the process in 19.997 seconds of CPU time (5.002 seconds of
wall time), only .003 seconds of that was system time, the rest was
user time. The unmodified kernel killed the process in 20.001 seconds
of CPU (5.014 seconds of wall time) of which .016 seconds was system
time. Really, though, the results were too close to call. The results
were essentially the same with no itimer running.
Case 5: With a soft limit of 20 seconds and a hard limit of 2000 seconds
(where the hard limit would never be reached) and an itimer running,
the modified kernel exhibited worse tick accuracy than the unmodified
kernel: .050 seconds/tick versus .028 seconds/tick. Otherwise,
performance was almost indistinguishable. With no itimer running this
test exhibited virtually identical behavior and times in both cases.
In times past I did some limited performance testing. those results are below.
On a four-cpu Opteron system without this fix, a sixteen-thread test executed
in 3569.991 seconds, of which user was 3568.435s and system was 1.556s. On
the same system with the fix, user and elapsed time were about the same, but
system time dropped to 0.007 seconds. Performance with eight, four and one
thread were comparable. Interestingly, the timer ticks with the fix seemed
more accurate: The sixteen-thread test with the fix received 149543 ticks
for 0.024 seconds per tick, while the same test without the fix received 58720
for 0.061 seconds per tick. Both cases were configured for an interval of
0.01 seconds. Again, the other tests were comparable. Each thread in this
test computed the primes up to 25,000,000.
I also did a test with a large number of threads, 100,000 threads, which is
impossible without the fix. In this case each thread computed the primes only
up to 10,000 (to make the runtime manageable). System time dominated, at
1546.968 seconds out of a total 2176.906 seconds (giving a user time of
629.938s). It received 147651 ticks for 0.015 seconds per tick, still quite
accurate. There is obviously no comparable test without the fix.
Signed-off-by: Frank Mayhar <fmayhar@google.com>
Cc: Roland McGrath <roland@redhat.com>
Cc: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-09-12 23:54:39 +07:00
|
|
|
account_group_system_time(p, cputime);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Add system time to cpustat. */
|
|
|
|
tmp = cputime_to_cputime64(cputime);
|
|
|
|
if (hardirq_count() - hardirq_offset)
|
|
|
|
cpustat->irq = cputime64_add(cpustat->irq, tmp);
|
|
|
|
else if (softirq_count())
|
|
|
|
cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
|
|
|
|
else
|
2008-12-31 21:11:38 +07:00
|
|
|
cpustat->system = cputime64_add(cpustat->system, tmp);
|
|
|
|
|
2009-03-31 11:32:22 +07:00
|
|
|
cpuacct_update_stats(p, CPUACCT_STAT_SYSTEM, cputime);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Account for system time used */
|
|
|
|
acct_update_integrals(p);
|
|
|
|
}
|
|
|
|
|
2007-10-18 17:06:34 +07:00
|
|
|
/*
|
2005-04-17 05:20:36 +07:00
|
|
|
* Account for involuntary wait time.
|
|
|
|
* @steal: the cpu time spent in involuntary wait
|
2007-10-18 17:06:34 +07:00
|
|
|
*/
|
2008-12-31 21:11:38 +07:00
|
|
|
void account_steal_time(cputime_t cputime)
|
2007-10-18 17:06:34 +07:00
|
|
|
{
|
2008-12-31 21:11:38 +07:00
|
|
|
struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
|
|
|
|
cputime64_t cputime64 = cputime_to_cputime64(cputime);
|
|
|
|
|
|
|
|
cpustat->steal = cputime64_add(cpustat->steal, cputime64);
|
2007-10-18 17:06:34 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2008-12-31 21:11:38 +07:00
|
|
|
* Account for idle time.
|
|
|
|
* @cputime: the cpu time spent in idle wait
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-12-31 21:11:38 +07:00
|
|
|
void account_idle_time(cputime_t cputime)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
|
2008-12-31 21:11:38 +07:00
|
|
|
cputime64_t cputime64 = cputime_to_cputime64(cputime);
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = this_rq();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-12-31 21:11:38 +07:00
|
|
|
if (atomic_read(&rq->nr_iowait) > 0)
|
|
|
|
cpustat->iowait = cputime64_add(cpustat->iowait, cputime64);
|
|
|
|
else
|
|
|
|
cpustat->idle = cputime64_add(cpustat->idle, cputime64);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-12-31 21:11:38 +07:00
|
|
|
#ifndef CONFIG_VIRT_CPU_ACCOUNTING
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Account a single tick of cpu time.
|
|
|
|
* @p: the process that the cpu time gets accounted to
|
|
|
|
* @user_tick: indicates if the tick is a user or a system tick
|
|
|
|
*/
|
|
|
|
void account_process_tick(struct task_struct *p, int user_tick)
|
|
|
|
{
|
2009-07-29 17:15:29 +07:00
|
|
|
cputime_t one_jiffy_scaled = cputime_to_scaled(cputime_one_jiffy);
|
2008-12-31 21:11:38 +07:00
|
|
|
struct rq *rq = this_rq();
|
|
|
|
|
|
|
|
if (user_tick)
|
2009-07-29 17:15:29 +07:00
|
|
|
account_user_time(p, cputime_one_jiffy, one_jiffy_scaled);
|
2009-04-29 19:44:49 +07:00
|
|
|
else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))
|
2009-07-29 17:15:29 +07:00
|
|
|
account_system_time(p, HARDIRQ_OFFSET, cputime_one_jiffy,
|
2008-12-31 21:11:38 +07:00
|
|
|
one_jiffy_scaled);
|
|
|
|
else
|
2009-07-29 17:15:29 +07:00
|
|
|
account_idle_time(cputime_one_jiffy);
|
2008-12-31 21:11:38 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Account multiple ticks of steal time.
|
|
|
|
* @p: the process from which the cpu time has been stolen
|
|
|
|
* @ticks: number of stolen ticks
|
|
|
|
*/
|
|
|
|
void account_steal_ticks(unsigned long ticks)
|
|
|
|
{
|
|
|
|
account_steal_time(jiffies_to_cputime(ticks));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Account multiple ticks of idle time.
|
|
|
|
* @ticks: number of stolen ticks
|
|
|
|
*/
|
|
|
|
void account_idle_ticks(unsigned long ticks)
|
|
|
|
{
|
|
|
|
account_idle_time(jiffies_to_cputime(ticks));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-12-31 21:11:38 +07:00
|
|
|
#endif
|
|
|
|
|
2008-09-05 23:12:23 +07:00
|
|
|
/*
|
|
|
|
* Use precise platform statistics if available:
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
2009-11-26 12:48:30 +07:00
|
|
|
void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
|
2008-09-05 23:12:23 +07:00
|
|
|
{
|
2009-12-02 15:26:47 +07:00
|
|
|
*ut = p->utime;
|
|
|
|
*st = p->stime;
|
2008-09-05 23:12:23 +07:00
|
|
|
}
|
|
|
|
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
|
2008-09-05 23:12:23 +07:00
|
|
|
{
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
struct task_cputime cputime;
|
|
|
|
|
|
|
|
thread_group_cputime(p, &cputime);
|
|
|
|
|
|
|
|
*ut = cputime.utime;
|
|
|
|
*st = cputime.stime;
|
2008-09-05 23:12:23 +07:00
|
|
|
}
|
|
|
|
#else
|
2009-11-12 11:33:45 +07:00
|
|
|
|
|
|
|
#ifndef nsecs_to_cputime
|
2009-11-26 12:49:27 +07:00
|
|
|
# define nsecs_to_cputime(__nsecs) nsecs_to_jiffies(__nsecs)
|
2009-11-12 11:33:45 +07:00
|
|
|
#endif
|
|
|
|
|
2009-11-26 12:48:30 +07:00
|
|
|
void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
|
2008-09-05 23:12:23 +07:00
|
|
|
{
|
2009-12-02 15:26:47 +07:00
|
|
|
cputime_t rtime, utime = p->utime, total = cputime_add(utime, p->stime);
|
2008-09-05 23:12:23 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use CFS's precise accounting:
|
|
|
|
*/
|
2009-11-26 12:48:30 +07:00
|
|
|
rtime = nsecs_to_cputime(p->se.sum_exec_runtime);
|
2008-09-05 23:12:23 +07:00
|
|
|
|
|
|
|
if (total) {
|
2009-11-26 12:48:30 +07:00
|
|
|
u64 temp;
|
|
|
|
|
|
|
|
temp = (u64)(rtime * utime);
|
2008-09-05 23:12:23 +07:00
|
|
|
do_div(temp, total);
|
2009-11-26 12:48:30 +07:00
|
|
|
utime = (cputime_t)temp;
|
|
|
|
} else
|
|
|
|
utime = rtime;
|
2008-09-05 23:12:23 +07:00
|
|
|
|
2009-11-26 12:48:30 +07:00
|
|
|
/*
|
|
|
|
* Compare with previous values, to keep monotonicity:
|
|
|
|
*/
|
2009-11-12 11:33:45 +07:00
|
|
|
p->prev_utime = max(p->prev_utime, utime);
|
2009-12-02 15:26:47 +07:00
|
|
|
p->prev_stime = max(p->prev_stime, cputime_sub(rtime, p->prev_utime));
|
2008-09-05 23:12:23 +07:00
|
|
|
|
2009-12-02 15:26:47 +07:00
|
|
|
*ut = p->prev_utime;
|
|
|
|
*st = p->prev_stime;
|
2008-09-05 23:12:23 +07:00
|
|
|
}
|
|
|
|
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
/*
|
|
|
|
* Must be called with siglock held.
|
|
|
|
*/
|
|
|
|
void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
|
2008-09-05 23:12:23 +07:00
|
|
|
{
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
struct signal_struct *sig = p->signal;
|
|
|
|
struct task_cputime cputime;
|
|
|
|
cputime_t rtime, utime, total;
|
2008-09-05 23:12:23 +07:00
|
|
|
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
thread_group_cputime(p, &cputime);
|
2008-09-05 23:12:23 +07:00
|
|
|
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
total = cputime_add(cputime.utime, cputime.stime);
|
|
|
|
rtime = nsecs_to_cputime(cputime.sum_exec_runtime);
|
2008-09-05 23:12:23 +07:00
|
|
|
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
if (total) {
|
|
|
|
u64 temp;
|
2008-09-05 23:12:23 +07:00
|
|
|
|
sched, cputime: Introduce thread_group_times()
This is a real fix for problem of utime/stime values decreasing
described in the thread:
http://lkml.org/lkml/2009/11/3/522
Now cputime is accounted in the following way:
- {u,s}time in task_struct are increased every time when the thread
is interrupted by a tick (timer interrupt).
- When a thread exits, its {u,s}time are added to signal->{u,s}time,
after adjusted by task_times().
- When all threads in a thread_group exits, accumulated {u,s}time
(and also c{u,s}time) in signal struct are added to c{u,s}time
in signal struct of the group's parent.
So {u,s}time in task struct are "raw" tick count, while
{u,s}time and c{u,s}time in signal struct are "adjusted" values.
And accounted values are used by:
- task_times(), to get cputime of a thread:
This function returns adjusted values that originates from raw
{u,s}time and scaled by sum_exec_runtime that accounted by CFS.
- thread_group_cputime(), to get cputime of a thread group:
This function returns sum of all {u,s}time of living threads in
the group, plus {u,s}time in the signal struct that is sum of
adjusted cputimes of all exited threads belonged to the group.
The problem is the return value of thread_group_cputime(),
because it is mixed sum of "raw" value and "adjusted" value:
group's {u,s}time = foreach(thread){{u,s}time} + exited({u,s}time)
This misbehavior can break {u,s}time monotonicity.
Assume that if there is a thread that have raw values greater
than adjusted values (e.g. interrupted by 1000Hz ticks 50 times
but only runs 45ms) and if it exits, cputime will decrease (e.g.
-5ms).
To fix this, we could do:
group's {u,s}time = foreach(t){task_times(t)} + exited({u,s}time)
But task_times() contains hard divisions, so applying it for
every thread should be avoided.
This patch fixes the above problem in the following way:
- Modify thread's exit (= __exit_signal()) not to use task_times().
It means {u,s}time in signal struct accumulates raw values instead
of adjusted values. As the result it makes thread_group_cputime()
to return pure sum of "raw" values.
- Introduce a new function thread_group_times(*task, *utime, *stime)
that converts "raw" values of thread_group_cputime() to "adjusted"
values, in same calculation procedure as task_times().
- Modify group's exit (= wait_task_zombie()) to use this introduced
thread_group_times(). It make c{u,s}time in signal struct to
have adjusted values like before this patch.
- Replace some thread_group_cputime() by thread_group_times().
This replacements are only applied where conveys the "adjusted"
cputime to users, and where already uses task_times() near by it.
(i.e. sys_times(), getrusage(), and /proc/<PID>/stat.)
This patch have a positive side effect:
- Before this patch, if a group contains many short-life threads
(e.g. runs 0.9ms and not interrupted by ticks), the group's
cputime could be invisible since thread's cputime was accumulated
after adjusted: imagine adjustment function as adj(ticks, runtime),
{adj(0, 0.9) + adj(0, 0.9) + ....} = {0 + 0 + ....} = 0.
After this patch it will not happen because the adjustment is
applied after accumulated.
v2:
- remove if()s, put new variables into signal_struct.
Signed-off-by: Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Spencer Candland <spencer@bluehost.com>
Cc: Americo Wang <xiyou.wangcong@gmail.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Balbir Singh <balbir@in.ibm.com>
Cc: Stanislaw Gruszka <sgruszka@redhat.com>
LKML-Reference: <4B162517.8040909@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-02 15:28:07 +07:00
|
|
|
temp = (u64)(rtime * cputime.utime);
|
|
|
|
do_div(temp, total);
|
|
|
|
utime = (cputime_t)temp;
|
|
|
|
} else
|
|
|
|
utime = rtime;
|
|
|
|
|
|
|
|
sig->prev_utime = max(sig->prev_utime, utime);
|
|
|
|
sig->prev_stime = max(sig->prev_stime,
|
|
|
|
cputime_sub(rtime, sig->prev_utime));
|
|
|
|
|
|
|
|
*ut = sig->prev_utime;
|
|
|
|
*st = sig->prev_stime;
|
2008-09-05 23:12:23 +07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-12-10 17:20:22 +07:00
|
|
|
/*
|
|
|
|
* This function gets called by the timer code, with HZ frequency.
|
|
|
|
* We call it with interrupts disabled.
|
|
|
|
*
|
|
|
|
* It also gets called by the fork code, when changing the parent's
|
|
|
|
* timeslices.
|
|
|
|
*/
|
|
|
|
void scheduler_tick(void)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2007-07-09 23:51:59 +07:00
|
|
|
struct task_struct *curr = rq->curr;
|
2008-05-03 23:29:28 +07:00
|
|
|
|
|
|
|
sched_clock_tick();
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
2008-05-03 23:29:28 +07:00
|
|
|
update_rq_clock(rq);
|
2007-08-09 16:16:45 +07:00
|
|
|
update_cpu_load(rq);
|
2008-01-26 03:08:29 +07:00
|
|
|
curr->sched_class->task_tick(rq, curr, 0);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock(&rq->lock);
|
2006-12-10 17:20:22 +07:00
|
|
|
|
2009-12-27 17:51:52 +07:00
|
|
|
perf_event_task_tick(curr);
|
2009-05-23 23:28:55 +07:00
|
|
|
|
2006-12-10 17:20:23 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2007-07-09 23:51:59 +07:00
|
|
|
rq->idle_at_tick = idle_cpu(cpu);
|
|
|
|
trigger_load_balance(rq, cpu);
|
2006-12-10 17:20:23 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-04-02 13:18:25 +07:00
|
|
|
notrace unsigned long get_parent_ip(unsigned long addr)
|
2008-05-13 02:20:42 +07:00
|
|
|
{
|
|
|
|
if (in_lock_functions(addr)) {
|
|
|
|
addr = CALLER_ADDR2;
|
|
|
|
if (in_lock_functions(addr))
|
|
|
|
addr = CALLER_ADDR3;
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-23 07:01:40 +07:00
|
|
|
#if defined(CONFIG_PREEMPT) && (defined(CONFIG_DEBUG_PREEMPT) || \
|
|
|
|
defined(CONFIG_PREEMPT_TRACER))
|
|
|
|
|
2008-02-24 06:24:04 +07:00
|
|
|
void __kprobes add_preempt_count(int val)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-05-13 02:20:42 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PREEMPT
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Underflow?
|
|
|
|
*/
|
2006-07-03 14:24:33 +07:00
|
|
|
if (DEBUG_LOCKS_WARN_ON((preempt_count() < 0)))
|
|
|
|
return;
|
2008-05-13 02:20:42 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
preempt_count() += val;
|
2008-05-13 02:20:42 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PREEMPT
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Spinlock count overflowing soon?
|
|
|
|
*/
|
2006-12-10 17:20:38 +07:00
|
|
|
DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >=
|
|
|
|
PREEMPT_MASK - 10);
|
2008-05-13 02:20:42 +07:00
|
|
|
#endif
|
|
|
|
if (preempt_count() == val)
|
|
|
|
trace_preempt_off(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(add_preempt_count);
|
|
|
|
|
2008-02-24 06:24:04 +07:00
|
|
|
void __kprobes sub_preempt_count(int val)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-05-13 02:20:42 +07:00
|
|
|
#ifdef CONFIG_DEBUG_PREEMPT
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Underflow?
|
|
|
|
*/
|
2009-01-12 19:00:50 +07:00
|
|
|
if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
|
2006-07-03 14:24:33 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Is the spinlock portion underflowing?
|
|
|
|
*/
|
2006-07-03 14:24:33 +07:00
|
|
|
if (DEBUG_LOCKS_WARN_ON((val < PREEMPT_MASK) &&
|
|
|
|
!(preempt_count() & PREEMPT_MASK)))
|
|
|
|
return;
|
2008-05-13 02:20:42 +07:00
|
|
|
#endif
|
2006-07-03 14:24:33 +07:00
|
|
|
|
2008-05-13 02:20:42 +07:00
|
|
|
if (preempt_count() == val)
|
|
|
|
trace_preempt_on(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
|
2005-04-17 05:20:36 +07:00
|
|
|
preempt_count() -= val;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sub_preempt_count);
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2007-07-09 23:51:59 +07:00
|
|
|
* Print scheduling while atomic bug:
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-07-09 23:51:59 +07:00
|
|
|
static noinline void __schedule_bug(struct task_struct *prev)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-24 23:23:50 +07:00
|
|
|
struct pt_regs *regs = get_irq_regs();
|
|
|
|
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
|
|
|
|
prev->comm, prev->pid, preempt_count());
|
2007-10-24 23:23:50 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
debug_show_held_locks(prev);
|
2008-05-23 23:05:58 +07:00
|
|
|
print_modules();
|
2007-07-09 23:51:59 +07:00
|
|
|
if (irqs_disabled())
|
|
|
|
print_irqtrace_events(prev);
|
2007-10-24 23:23:50 +07:00
|
|
|
|
|
|
|
if (regs)
|
|
|
|
show_regs(regs);
|
|
|
|
else
|
|
|
|
dump_stack();
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* Various schedule()-time debugging checks and statistics:
|
|
|
|
*/
|
|
|
|
static inline void schedule_debug(struct task_struct *prev)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2007-12-05 21:46:09 +07:00
|
|
|
* Test if we are atomic. Since do_exit() needs to call into
|
2005-04-17 05:20:36 +07:00
|
|
|
* schedule() atomically, we ignore that path for now.
|
|
|
|
* Otherwise, whine if we are scheduling when we should not be.
|
|
|
|
*/
|
2008-05-14 04:44:11 +07:00
|
|
|
if (unlikely(in_atomic_preempt_off() && !prev->exit_state))
|
2007-07-09 23:51:59 +07:00
|
|
|
__schedule_bug(prev);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
profile_hit(SCHED_PROFILING, __builtin_return_address(0));
|
|
|
|
|
2007-10-15 22:00:12 +07:00
|
|
|
schedstat_inc(this_rq(), sched_count);
|
2007-10-15 22:00:10 +07:00
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
|
|
if (unlikely(prev->lock_depth >= 0)) {
|
2007-10-15 22:00:12 +07:00
|
|
|
schedstat_inc(this_rq(), bkl_count);
|
|
|
|
schedstat_inc(prev, sched_info.bkl_count);
|
2007-10-15 22:00:10 +07:00
|
|
|
}
|
|
|
|
#endif
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2009-11-30 19:00:37 +07:00
|
|
|
static void put_prev_task(struct rq *rq, struct task_struct *prev)
|
2009-03-11 01:08:11 +07:00
|
|
|
{
|
2010-03-11 23:16:20 +07:00
|
|
|
if (prev->se.on_rq)
|
|
|
|
update_rq_clock(rq);
|
|
|
|
rq->skip_clock_update = 0;
|
2009-11-30 19:00:37 +07:00
|
|
|
prev->sched_class->put_prev_task(rq, prev);
|
2009-03-11 01:08:11 +07:00
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* Pick up the highest-prio task:
|
|
|
|
*/
|
|
|
|
static inline struct task_struct *
|
2009-03-02 12:55:26 +07:00
|
|
|
pick_next_task(struct rq *rq)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
2007-10-15 22:00:12 +07:00
|
|
|
const struct sched_class *class;
|
2007-07-09 23:51:59 +07:00
|
|
|
struct task_struct *p;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2007-07-09 23:51:59 +07:00
|
|
|
* Optimization: we know that if all tasks are in
|
|
|
|
* the fair class we can call that function directly:
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-07-09 23:51:59 +07:00
|
|
|
if (likely(rq->nr_running == rq->cfs.nr_running)) {
|
2007-08-09 16:16:48 +07:00
|
|
|
p = fair_sched_class.pick_next_task(rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
if (likely(p))
|
|
|
|
return p;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
class = sched_class_highest;
|
|
|
|
for ( ; ; ) {
|
2007-08-09 16:16:48 +07:00
|
|
|
p = class->pick_next_task(rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
if (p)
|
|
|
|
return p;
|
|
|
|
/*
|
|
|
|
* Will never be NULL as the idle class always
|
|
|
|
* returns a non-NULL p:
|
|
|
|
*/
|
|
|
|
class = class->next;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* schedule() is the main scheduler function.
|
|
|
|
*/
|
2009-03-13 18:21:26 +07:00
|
|
|
asmlinkage void __sched schedule(void)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
|
|
|
struct task_struct *prev, *next;
|
2008-02-16 00:56:36 +07:00
|
|
|
unsigned long *switch_count;
|
2007-07-09 23:51:59 +07:00
|
|
|
struct rq *rq;
|
2008-07-18 23:01:23 +07:00
|
|
|
int cpu;
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2009-03-13 18:21:26 +07:00
|
|
|
need_resched:
|
|
|
|
preempt_disable();
|
2007-07-09 23:51:59 +07:00
|
|
|
cpu = smp_processor_id();
|
|
|
|
rq = cpu_rq(cpu);
|
rcu: refactor RCU's context-switch handling
The addition of preemptible RCU to treercu resulted in a bit of
confusion and inefficiency surrounding the handling of context switches
for RCU-sched and for RCU-preempt. For RCU-sched, a context switch
is a quiescent state, pure and simple, just like it always has been.
For RCU-preempt, a context switch is in no way a quiescent state, but
special handling is required when a task blocks in an RCU read-side
critical section.
However, the callout from the scheduler and the outer loop in ksoftirqd
still calls something named rcu_sched_qs(), whose name is no longer
accurate. Furthermore, when rcu_check_callbacks() notes an RCU-sched
quiescent state, it ends up unnecessarily (though harmlessly, aside
from the performance hit) enqueuing the current task if it happens to
be running in an RCU-preempt read-side critical section. This not only
increases the maximum latency of scheduler_tick(), it also needlessly
increases the overhead of the next outermost rcu_read_unlock() invocation.
This patch addresses this situation by separating the notion of RCU's
context-switch handling from that of RCU-sched's quiescent states.
The context-switch handling is covered by rcu_note_context_switch() in
general and by rcu_preempt_note_context_switch() for preemptible RCU.
This permits rcu_sched_qs() to handle quiescent states and only quiescent
states. It also reduces the maximum latency of scheduler_tick(), though
probably by much less than a microsecond. Finally, it means that tasks
within preemptible-RCU read-side critical sections avoid incurring the
overhead of queuing unless there really is a context switch.
Suggested-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Acked-by: Lai Jiangshan <laijs@cn.fujitsu.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <peterz@infradead.org>
2010-04-02 07:37:01 +07:00
|
|
|
rcu_note_context_switch(cpu);
|
2007-07-09 23:51:59 +07:00
|
|
|
prev = rq->curr;
|
|
|
|
switch_count = &prev->nivcsw;
|
|
|
|
|
|
|
|
release_kernel_lock(prev);
|
|
|
|
need_resched_nonpreemptible:
|
|
|
|
|
|
|
|
schedule_debug(prev);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-18 23:01:23 +07:00
|
|
|
if (sched_feat(HRTICK))
|
2008-05-13 02:20:55 +07:00
|
|
|
hrtick_clear(rq);
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irq(&rq->lock);
|
2007-10-15 22:00:13 +07:00
|
|
|
clear_tsk_need_resched(prev);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
|
sched: fix TASK_WAKEKILL vs SIGKILL race
schedule() has the special "TASK_INTERRUPTIBLE && signal_pending()" case,
this allows us to do
current->state = TASK_INTERRUPTIBLE;
schedule();
without fear to sleep with pending signal.
However, the code like
current->state = TASK_KILLABLE;
schedule();
is not right, schedule() doesn't take TASK_WAKEKILL into account. This means
that mutex_lock_killable(), wait_for_completion_killable(), down_killable(),
schedule_timeout_killable() can miss SIGKILL (and btw the second SIGKILL has
no effect).
Introduce the new helper, signal_pending_state(), and change schedule() to
use it. Hopefully it will have more users, that is why the task's state is
passed separately.
Note this "__TASK_STOPPED | __TASK_TRACED" check in signal_pending_state().
This is needed to preserve the current behaviour (ptrace_notify). I hope
this check will be removed soon, but this (afaics good) change needs the
separate discussion.
The fast path is "(state & (INTERRUPTIBLE | WAKEKILL)) + signal_pending(p)",
basically the same that schedule() does now. However, this patch of course
bloats schedule().
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-06-09 00:20:41 +07:00
|
|
|
if (unlikely(signal_pending_state(prev->state, prev)))
|
2005-04-17 05:20:36 +07:00
|
|
|
prev->state = TASK_RUNNING;
|
sched: fix TASK_WAKEKILL vs SIGKILL race
schedule() has the special "TASK_INTERRUPTIBLE && signal_pending()" case,
this allows us to do
current->state = TASK_INTERRUPTIBLE;
schedule();
without fear to sleep with pending signal.
However, the code like
current->state = TASK_KILLABLE;
schedule();
is not right, schedule() doesn't take TASK_WAKEKILL into account. This means
that mutex_lock_killable(), wait_for_completion_killable(), down_killable(),
schedule_timeout_killable() can miss SIGKILL (and btw the second SIGKILL has
no effect).
Introduce the new helper, signal_pending_state(), and change schedule() to
use it. Hopefully it will have more users, that is why the task's state is
passed separately.
Note this "__TASK_STOPPED | __TASK_TRACED" check in signal_pending_state().
This is needed to preserve the current behaviour (ptrace_notify). I hope
this check will be removed soon, but this (afaics good) change needs the
separate discussion.
The fast path is "(state & (INTERRUPTIBLE | WAKEKILL)) + signal_pending(p)",
basically the same that schedule() does now. However, this patch of course
bloats schedule().
Signed-off-by: Oleg Nesterov <oleg@tv-sign.ru>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-06-09 00:20:41 +07:00
|
|
|
else
|
2010-03-24 22:38:48 +07:00
|
|
|
deactivate_task(rq, prev, DEQUEUE_SLEEP);
|
2007-07-09 23:51:59 +07:00
|
|
|
switch_count = &prev->nvcsw;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2009-07-29 22:08:47 +07:00
|
|
|
pre_schedule(rq, prev);
|
2008-01-26 03:08:07 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
if (unlikely(!rq->nr_running))
|
2005-04-17 05:20:36 +07:00
|
|
|
idle_balance(cpu, rq);
|
|
|
|
|
2009-03-11 01:08:11 +07:00
|
|
|
put_prev_task(rq, prev);
|
2009-03-02 12:55:26 +07:00
|
|
|
next = pick_next_task(rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (likely(prev != next)) {
|
2008-04-29 16:08:59 +07:00
|
|
|
sched_info_switch(prev, next);
|
2009-12-27 17:51:52 +07:00
|
|
|
perf_event_task_sched_out(prev, next);
|
2008-04-29 16:08:59 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
rq->nr_switches++;
|
|
|
|
rq->curr = next;
|
|
|
|
++*switch_count;
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
context_switch(rq, prev, next); /* unlocks the rq */
|
2008-01-26 03:08:29 +07:00
|
|
|
/*
|
|
|
|
* the context switch might have flipped the stack from under
|
|
|
|
* us, hence refresh the local variables.
|
|
|
|
*/
|
|
|
|
cpu = smp_processor_id();
|
|
|
|
rq = cpu_rq(cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-07-29 22:08:47 +07:00
|
|
|
post_schedule(rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-01-11 13:21:25 +07:00
|
|
|
if (unlikely(reacquire_kernel_lock(current) < 0)) {
|
|
|
|
prev = rq->curr;
|
|
|
|
switch_count = &prev->nivcsw;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto need_resched_nonpreemptible;
|
2010-01-11 13:21:25 +07:00
|
|
|
}
|
2008-01-26 03:08:29 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
preempt_enable_no_resched();
|
2009-03-13 18:21:26 +07:00
|
|
|
if (need_resched())
|
2005-04-17 05:20:36 +07:00
|
|
|
goto need_resched;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(schedule);
|
|
|
|
|
2009-12-03 02:49:17 +07:00
|
|
|
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
|
2009-01-12 20:01:47 +07:00
|
|
|
/*
|
|
|
|
* Look out! "owner" is an entirely speculative pointer
|
|
|
|
* access and not reliable.
|
|
|
|
*/
|
|
|
|
int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner)
|
|
|
|
{
|
|
|
|
unsigned int cpu;
|
|
|
|
struct rq *rq;
|
|
|
|
|
|
|
|
if (!sched_feat(OWNER_SPIN))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_PAGEALLOC
|
|
|
|
/*
|
|
|
|
* Need to access the cpu field knowing that
|
|
|
|
* DEBUG_PAGEALLOC could have unmapped it if
|
|
|
|
* the mutex owner just released it and exited.
|
|
|
|
*/
|
|
|
|
if (probe_kernel_address(&owner->cpu, cpu))
|
2010-04-17 04:20:00 +07:00
|
|
|
return 0;
|
2009-01-12 20:01:47 +07:00
|
|
|
#else
|
|
|
|
cpu = owner->cpu;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Even if the access succeeded (likely case),
|
|
|
|
* the cpu field may no longer be valid.
|
|
|
|
*/
|
|
|
|
if (cpu >= nr_cpumask_bits)
|
2010-04-17 04:20:00 +07:00
|
|
|
return 0;
|
2009-01-12 20:01:47 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to validate that we can do a
|
|
|
|
* get_cpu() and that we have the percpu area.
|
|
|
|
*/
|
|
|
|
if (!cpu_online(cpu))
|
2010-04-17 04:20:00 +07:00
|
|
|
return 0;
|
2009-01-12 20:01:47 +07:00
|
|
|
|
|
|
|
rq = cpu_rq(cpu);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
/*
|
|
|
|
* Owner changed, break to re-assess state.
|
|
|
|
*/
|
|
|
|
if (lock->owner != owner)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Is that owner really running on that cpu?
|
|
|
|
*/
|
|
|
|
if (task_thread_info(rq->curr) != owner || need_resched())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu_relax();
|
|
|
|
}
|
2010-04-17 04:20:00 +07:00
|
|
|
|
2009-01-12 20:01:47 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_PREEMPT
|
|
|
|
/*
|
2006-07-10 18:43:52 +07:00
|
|
|
* this is the entry point to schedule() from in-kernel preemption
|
2007-12-05 21:46:09 +07:00
|
|
|
* off of preempt_enable. Kernel preemptions off return from interrupt
|
2005-04-17 05:20:36 +07:00
|
|
|
* occur there and call schedule directly.
|
|
|
|
*/
|
2010-06-03 08:52:29 +07:00
|
|
|
asmlinkage void __sched notrace preempt_schedule(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct thread_info *ti = current_thread_info();
|
2008-01-26 03:08:33 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* If there is a non-zero preempt_count or interrupts are disabled,
|
2007-12-05 21:46:09 +07:00
|
|
|
* we do not want to preempt the current task. Just return..
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-10-11 15:21:52 +07:00
|
|
|
if (likely(ti->preempt_count || irqs_disabled()))
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
do {
|
2010-06-03 08:52:29 +07:00
|
|
|
add_preempt_count_notrace(PREEMPT_ACTIVE);
|
2007-10-15 22:00:14 +07:00
|
|
|
schedule();
|
2010-06-03 08:52:29 +07:00
|
|
|
sub_preempt_count_notrace(PREEMPT_ACTIVE);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* Check again in case we missed a preemption opportunity
|
|
|
|
* between schedule and now.
|
|
|
|
*/
|
|
|
|
barrier();
|
2009-03-06 18:40:20 +07:00
|
|
|
} while (need_resched());
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(preempt_schedule);
|
|
|
|
|
|
|
|
/*
|
2006-07-10 18:43:52 +07:00
|
|
|
* this is the entry point to schedule() from kernel preemption
|
2005-04-17 05:20:36 +07:00
|
|
|
* off of irq context.
|
|
|
|
* Note, that this is called and return with irqs disabled. This will
|
|
|
|
* protect us against recursive calling from irq.
|
|
|
|
*/
|
|
|
|
asmlinkage void __sched preempt_schedule_irq(void)
|
|
|
|
{
|
|
|
|
struct thread_info *ti = current_thread_info();
|
2008-01-26 03:08:33 +07:00
|
|
|
|
2006-07-10 18:43:52 +07:00
|
|
|
/* Catch callers which need to be fixed */
|
2005-04-17 05:20:36 +07:00
|
|
|
BUG_ON(ti->preempt_count || !irqs_disabled());
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
do {
|
|
|
|
add_preempt_count(PREEMPT_ACTIVE);
|
|
|
|
local_irq_enable();
|
|
|
|
schedule();
|
|
|
|
local_irq_disable();
|
|
|
|
sub_preempt_count(PREEMPT_ACTIVE);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* Check again in case we missed a preemption opportunity
|
|
|
|
* between schedule and now.
|
|
|
|
*/
|
|
|
|
barrier();
|
2009-03-06 18:40:20 +07:00
|
|
|
} while (need_resched());
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PREEMPT */
|
|
|
|
|
2009-09-16 00:14:42 +07:00
|
|
|
int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
|
2005-09-10 14:26:11 +07:00
|
|
|
void *key)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-09-16 00:14:42 +07:00
|
|
|
return try_to_wake_up(curr->private, mode, wake_flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(default_wake_function);
|
|
|
|
|
|
|
|
/*
|
2007-12-05 21:46:09 +07:00
|
|
|
* The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
|
|
|
|
* wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
|
2005-04-17 05:20:36 +07:00
|
|
|
* number) then we wake all the non-exclusive tasks and one exclusive task.
|
|
|
|
*
|
|
|
|
* There are circumstances in which we can try to wake a task which has already
|
2007-12-05 21:46:09 +07:00
|
|
|
* started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
|
2005-04-17 05:20:36 +07:00
|
|
|
* zero in this (rare) case, and we handle it by continuing to scan the queue.
|
|
|
|
*/
|
2009-04-14 21:53:05 +07:00
|
|
|
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
|
2009-09-16 00:14:42 +07:00
|
|
|
int nr_exclusive, int wake_flags, void *key)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:02 +07:00
|
|
|
wait_queue_t *curr, *next;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:02 +07:00
|
|
|
list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
|
2006-07-03 14:25:40 +07:00
|
|
|
unsigned flags = curr->flags;
|
|
|
|
|
2009-09-16 00:14:42 +07:00
|
|
|
if (curr->func(curr, mode, wake_flags, key) &&
|
2006-07-03 14:25:40 +07:00
|
|
|
(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __wake_up - wake up threads blocked on a waitqueue.
|
|
|
|
* @q: the waitqueue
|
|
|
|
* @mode: which threads
|
|
|
|
* @nr_exclusive: how many wake-one or wake-many threads to wake up
|
2005-05-01 22:59:26 +07:00
|
|
|
* @key: is directly passed to the wakeup function
|
2009-04-28 21:01:38 +07:00
|
|
|
*
|
|
|
|
* It may be assumed that this function implies a write memory barrier before
|
|
|
|
* changing the task state if and only if any tasks are woken up.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-02-08 19:19:53 +07:00
|
|
|
void __wake_up(wait_queue_head_t *q, unsigned int mode,
|
2005-09-10 14:26:11 +07:00
|
|
|
int nr_exclusive, void *key)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&q->lock, flags);
|
|
|
|
__wake_up_common(q, mode, nr_exclusive, 0, key);
|
|
|
|
spin_unlock_irqrestore(&q->lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__wake_up);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Same as __wake_up but called with the spinlock in wait_queue_head_t held.
|
|
|
|
*/
|
2008-02-08 19:19:53 +07:00
|
|
|
void __wake_up_locked(wait_queue_head_t *q, unsigned int mode)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
__wake_up_common(q, mode, 1, 0, NULL);
|
|
|
|
}
|
2010-05-05 17:53:11 +07:00
|
|
|
EXPORT_SYMBOL_GPL(__wake_up_locked);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
epoll keyed wakeups: add __wake_up_locked_key() and __wake_up_sync_key()
This patchset introduces wakeup hints for some of the most popular (from
epoll POV) devices, so that epoll code can avoid spurious wakeups on its
waiters.
The problem with epoll is that the callback-based wakeups do not, ATM,
carry any information about the events the wakeup is related to. So the
only choice epoll has (not being able to call f_op->poll() from inside the
callback), is to add the file* to a ready-list and resolve the real events
later on, at epoll_wait() (or its own f_op->poll()) time. This can cause
spurious wakeups, since the wake_up() itself might be for an event the
caller is not interested into.
The rate of these spurious wakeup can be pretty high in case of many
network sockets being monitored.
By allowing devices to report the events the wakeups refer to (at least
the two major classes - POLLIN/POLLOUT), we are able to spare useless
wakeups by proper handling inside the epoll's poll callback.
Epoll will have in any case to call f_op->poll() on the file* later on,
since the change to be done in order to have the full event set sent via
wakeup, is too invasive for the way our f_op->poll() system works (the
full event set is calculated inside the poll function - there are too many
of them to even start thinking the change - also poll/select would need
change too).
Epoll is changed in a way that both devices which send event hints, and
the ones that don't, are correctly handled. The former will gain some
efficiency though.
As a general rule for devices, would be to add an event mask by using
key-aware wakeup macros, when making up poll wait queues. I tested it
(together with the epoll's poll fix patch Andrew has in -mm) and wakeups
for the supported devices are correctly filtered.
Test program available here:
http://www.xmailserver.org/epoll_test.c
This patch:
Nothing revolutionary here. Just using the available "key" that our
wakeup core already support. The __wake_up_locked_key() was no brainer,
since both __wake_up_locked() and __wake_up_locked_key() are thin wrappers
around __wake_up_common().
The __wake_up_sync() function had a body, so the choice was between
borrowing the body for __wake_up_sync_key() and calling it from
__wake_up_sync(), or make an inline and calling it from both. I chose the
former since in most archs it all resolves to "mov $0, REG; jmp ADDR".
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
Cc: William Lee Irwin III <wli@movementarian.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-01 05:24:20 +07:00
|
|
|
void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key)
|
|
|
|
{
|
|
|
|
__wake_up_common(q, mode, 1, 0, key);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
epoll keyed wakeups: add __wake_up_locked_key() and __wake_up_sync_key()
This patchset introduces wakeup hints for some of the most popular (from
epoll POV) devices, so that epoll code can avoid spurious wakeups on its
waiters.
The problem with epoll is that the callback-based wakeups do not, ATM,
carry any information about the events the wakeup is related to. So the
only choice epoll has (not being able to call f_op->poll() from inside the
callback), is to add the file* to a ready-list and resolve the real events
later on, at epoll_wait() (or its own f_op->poll()) time. This can cause
spurious wakeups, since the wake_up() itself might be for an event the
caller is not interested into.
The rate of these spurious wakeup can be pretty high in case of many
network sockets being monitored.
By allowing devices to report the events the wakeups refer to (at least
the two major classes - POLLIN/POLLOUT), we are able to spare useless
wakeups by proper handling inside the epoll's poll callback.
Epoll will have in any case to call f_op->poll() on the file* later on,
since the change to be done in order to have the full event set sent via
wakeup, is too invasive for the way our f_op->poll() system works (the
full event set is calculated inside the poll function - there are too many
of them to even start thinking the change - also poll/select would need
change too).
Epoll is changed in a way that both devices which send event hints, and
the ones that don't, are correctly handled. The former will gain some
efficiency though.
As a general rule for devices, would be to add an event mask by using
key-aware wakeup macros, when making up poll wait queues. I tested it
(together with the epoll's poll fix patch Andrew has in -mm) and wakeups
for the supported devices are correctly filtered.
Test program available here:
http://www.xmailserver.org/epoll_test.c
This patch:
Nothing revolutionary here. Just using the available "key" that our
wakeup core already support. The __wake_up_locked_key() was no brainer,
since both __wake_up_locked() and __wake_up_locked_key() are thin wrappers
around __wake_up_common().
The __wake_up_sync() function had a body, so the choice was between
borrowing the body for __wake_up_sync_key() and calling it from
__wake_up_sync(), or make an inline and calling it from both. I chose the
former since in most archs it all resolves to "mov $0, REG; jmp ADDR".
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
Cc: William Lee Irwin III <wli@movementarian.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-01 05:24:20 +07:00
|
|
|
* __wake_up_sync_key - wake up threads blocked on a waitqueue.
|
2005-04-17 05:20:36 +07:00
|
|
|
* @q: the waitqueue
|
|
|
|
* @mode: which threads
|
|
|
|
* @nr_exclusive: how many wake-one or wake-many threads to wake up
|
epoll keyed wakeups: add __wake_up_locked_key() and __wake_up_sync_key()
This patchset introduces wakeup hints for some of the most popular (from
epoll POV) devices, so that epoll code can avoid spurious wakeups on its
waiters.
The problem with epoll is that the callback-based wakeups do not, ATM,
carry any information about the events the wakeup is related to. So the
only choice epoll has (not being able to call f_op->poll() from inside the
callback), is to add the file* to a ready-list and resolve the real events
later on, at epoll_wait() (or its own f_op->poll()) time. This can cause
spurious wakeups, since the wake_up() itself might be for an event the
caller is not interested into.
The rate of these spurious wakeup can be pretty high in case of many
network sockets being monitored.
By allowing devices to report the events the wakeups refer to (at least
the two major classes - POLLIN/POLLOUT), we are able to spare useless
wakeups by proper handling inside the epoll's poll callback.
Epoll will have in any case to call f_op->poll() on the file* later on,
since the change to be done in order to have the full event set sent via
wakeup, is too invasive for the way our f_op->poll() system works (the
full event set is calculated inside the poll function - there are too many
of them to even start thinking the change - also poll/select would need
change too).
Epoll is changed in a way that both devices which send event hints, and
the ones that don't, are correctly handled. The former will gain some
efficiency though.
As a general rule for devices, would be to add an event mask by using
key-aware wakeup macros, when making up poll wait queues. I tested it
(together with the epoll's poll fix patch Andrew has in -mm) and wakeups
for the supported devices are correctly filtered.
Test program available here:
http://www.xmailserver.org/epoll_test.c
This patch:
Nothing revolutionary here. Just using the available "key" that our
wakeup core already support. The __wake_up_locked_key() was no brainer,
since both __wake_up_locked() and __wake_up_locked_key() are thin wrappers
around __wake_up_common().
The __wake_up_sync() function had a body, so the choice was between
borrowing the body for __wake_up_sync_key() and calling it from
__wake_up_sync(), or make an inline and calling it from both. I chose the
former since in most archs it all resolves to "mov $0, REG; jmp ADDR".
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
Cc: William Lee Irwin III <wli@movementarian.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-01 05:24:20 +07:00
|
|
|
* @key: opaque value to be passed to wakeup targets
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* The sync wakeup differs that the waker knows that it will schedule
|
|
|
|
* away soon, so while the target thread will be woken up, it will not
|
|
|
|
* be migrated to another CPU - ie. the two threads are 'synchronized'
|
|
|
|
* with each other. This can prevent needless bouncing between CPUs.
|
|
|
|
*
|
|
|
|
* On UP it can prevent extra preemption.
|
2009-04-28 21:01:38 +07:00
|
|
|
*
|
|
|
|
* It may be assumed that this function implies a write memory barrier before
|
|
|
|
* changing the task state if and only if any tasks are woken up.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
epoll keyed wakeups: add __wake_up_locked_key() and __wake_up_sync_key()
This patchset introduces wakeup hints for some of the most popular (from
epoll POV) devices, so that epoll code can avoid spurious wakeups on its
waiters.
The problem with epoll is that the callback-based wakeups do not, ATM,
carry any information about the events the wakeup is related to. So the
only choice epoll has (not being able to call f_op->poll() from inside the
callback), is to add the file* to a ready-list and resolve the real events
later on, at epoll_wait() (or its own f_op->poll()) time. This can cause
spurious wakeups, since the wake_up() itself might be for an event the
caller is not interested into.
The rate of these spurious wakeup can be pretty high in case of many
network sockets being monitored.
By allowing devices to report the events the wakeups refer to (at least
the two major classes - POLLIN/POLLOUT), we are able to spare useless
wakeups by proper handling inside the epoll's poll callback.
Epoll will have in any case to call f_op->poll() on the file* later on,
since the change to be done in order to have the full event set sent via
wakeup, is too invasive for the way our f_op->poll() system works (the
full event set is calculated inside the poll function - there are too many
of them to even start thinking the change - also poll/select would need
change too).
Epoll is changed in a way that both devices which send event hints, and
the ones that don't, are correctly handled. The former will gain some
efficiency though.
As a general rule for devices, would be to add an event mask by using
key-aware wakeup macros, when making up poll wait queues. I tested it
(together with the epoll's poll fix patch Andrew has in -mm) and wakeups
for the supported devices are correctly filtered.
Test program available here:
http://www.xmailserver.org/epoll_test.c
This patch:
Nothing revolutionary here. Just using the available "key" that our
wakeup core already support. The __wake_up_locked_key() was no brainer,
since both __wake_up_locked() and __wake_up_locked_key() are thin wrappers
around __wake_up_common().
The __wake_up_sync() function had a body, so the choice was between
borrowing the body for __wake_up_sync_key() and calling it from
__wake_up_sync(), or make an inline and calling it from both. I chose the
former since in most archs it all resolves to "mov $0, REG; jmp ADDR".
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
Cc: William Lee Irwin III <wli@movementarian.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-01 05:24:20 +07:00
|
|
|
void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
|
|
|
|
int nr_exclusive, void *key)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2009-09-15 00:55:44 +07:00
|
|
|
int wake_flags = WF_SYNC;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (unlikely(!q))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (unlikely(!nr_exclusive))
|
2009-09-15 00:55:44 +07:00
|
|
|
wake_flags = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&q->lock, flags);
|
2009-09-15 00:55:44 +07:00
|
|
|
__wake_up_common(q, mode, nr_exclusive, wake_flags, key);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&q->lock, flags);
|
|
|
|
}
|
epoll keyed wakeups: add __wake_up_locked_key() and __wake_up_sync_key()
This patchset introduces wakeup hints for some of the most popular (from
epoll POV) devices, so that epoll code can avoid spurious wakeups on its
waiters.
The problem with epoll is that the callback-based wakeups do not, ATM,
carry any information about the events the wakeup is related to. So the
only choice epoll has (not being able to call f_op->poll() from inside the
callback), is to add the file* to a ready-list and resolve the real events
later on, at epoll_wait() (or its own f_op->poll()) time. This can cause
spurious wakeups, since the wake_up() itself might be for an event the
caller is not interested into.
The rate of these spurious wakeup can be pretty high in case of many
network sockets being monitored.
By allowing devices to report the events the wakeups refer to (at least
the two major classes - POLLIN/POLLOUT), we are able to spare useless
wakeups by proper handling inside the epoll's poll callback.
Epoll will have in any case to call f_op->poll() on the file* later on,
since the change to be done in order to have the full event set sent via
wakeup, is too invasive for the way our f_op->poll() system works (the
full event set is calculated inside the poll function - there are too many
of them to even start thinking the change - also poll/select would need
change too).
Epoll is changed in a way that both devices which send event hints, and
the ones that don't, are correctly handled. The former will gain some
efficiency though.
As a general rule for devices, would be to add an event mask by using
key-aware wakeup macros, when making up poll wait queues. I tested it
(together with the epoll's poll fix patch Andrew has in -mm) and wakeups
for the supported devices are correctly filtered.
Test program available here:
http://www.xmailserver.org/epoll_test.c
This patch:
Nothing revolutionary here. Just using the available "key" that our
wakeup core already support. The __wake_up_locked_key() was no brainer,
since both __wake_up_locked() and __wake_up_locked_key() are thin wrappers
around __wake_up_common().
The __wake_up_sync() function had a body, so the choice was between
borrowing the body for __wake_up_sync_key() and calling it from
__wake_up_sync(), or make an inline and calling it from both. I chose the
former since in most archs it all resolves to "mov $0, REG; jmp ADDR".
Signed-off-by: Davide Libenzi <davidel@xmailserver.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
Cc: William Lee Irwin III <wli@movementarian.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-04-01 05:24:20 +07:00
|
|
|
EXPORT_SYMBOL_GPL(__wake_up_sync_key);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* __wake_up_sync - see __wake_up_sync_key()
|
|
|
|
*/
|
|
|
|
void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
|
|
|
|
{
|
|
|
|
__wake_up_sync_key(q, mode, nr_exclusive, NULL);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */
|
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* complete: - signals a single thread waiting on this completion
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
*
|
|
|
|
* This will wake up a single thread waiting on this completion. Threads will be
|
|
|
|
* awakened in the same order in which they were queued.
|
|
|
|
*
|
|
|
|
* See also complete_all(), wait_for_completion() and related routines.
|
2009-04-28 21:01:38 +07:00
|
|
|
*
|
|
|
|
* It may be assumed that this function implies a write memory barrier before
|
|
|
|
* changing the task state if and only if any tasks are woken up.
|
2008-08-26 15:26:54 +07:00
|
|
|
*/
|
2007-10-24 23:23:48 +07:00
|
|
|
void complete(struct completion *x)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&x->wait.lock, flags);
|
|
|
|
x->done++;
|
2007-12-06 23:07:07 +07:00
|
|
|
__wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&x->wait.lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(complete);
|
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* complete_all: - signals all threads waiting on this completion
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
*
|
|
|
|
* This will wake up all threads waiting on this particular completion event.
|
2009-04-28 21:01:38 +07:00
|
|
|
*
|
|
|
|
* It may be assumed that this function implies a write memory barrier before
|
|
|
|
* changing the task state if and only if any tasks are woken up.
|
2008-08-26 15:26:54 +07:00
|
|
|
*/
|
2007-10-24 23:23:48 +07:00
|
|
|
void complete_all(struct completion *x)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&x->wait.lock, flags);
|
|
|
|
x->done += UINT_MAX/2;
|
2007-12-06 23:07:07 +07:00
|
|
|
__wake_up_common(&x->wait, TASK_NORMAL, 0, 0, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&x->wait.lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(complete_all);
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
static inline long __sched
|
|
|
|
do_wait_for_common(struct completion *x, long timeout, int state)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
if (!x->done) {
|
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
|
2010-05-07 13:33:26 +07:00
|
|
|
__add_wait_queue_tail_exclusive(&x->wait, &wait);
|
2005-04-17 05:20:36 +07:00
|
|
|
do {
|
2008-08-21 06:54:41 +07:00
|
|
|
if (signal_pending_state(state, current)) {
|
2008-06-20 21:32:20 +07:00
|
|
|
timeout = -ERESTARTSYS;
|
|
|
|
break;
|
2007-10-15 22:00:14 +07:00
|
|
|
}
|
|
|
|
__set_current_state(state);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irq(&x->wait.lock);
|
|
|
|
timeout = schedule_timeout(timeout);
|
|
|
|
spin_lock_irq(&x->wait.lock);
|
2008-06-20 21:32:20 +07:00
|
|
|
} while (!x->done && timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
__remove_wait_queue(&x->wait, &wait);
|
2008-06-20 21:32:20 +07:00
|
|
|
if (!x->done)
|
|
|
|
return timeout;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
x->done--;
|
2008-06-20 21:32:20 +07:00
|
|
|
return timeout ?: 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
static long __sched
|
|
|
|
wait_for_common(struct completion *x, long timeout, int state)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
might_sleep();
|
|
|
|
|
|
|
|
spin_lock_irq(&x->wait.lock);
|
2007-10-15 22:00:14 +07:00
|
|
|
timeout = do_wait_for_common(x, timeout, state);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irq(&x->wait.lock);
|
2007-10-15 22:00:14 +07:00
|
|
|
return timeout;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* wait_for_completion: - waits for completion of a task
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
*
|
|
|
|
* This waits to be signaled for completion of a specific task. It is NOT
|
|
|
|
* interruptible and there is no timeout.
|
|
|
|
*
|
|
|
|
* See also similar routines (i.e. wait_for_completion_timeout()) with timeout
|
|
|
|
* and interrupt capability. Also see complete().
|
|
|
|
*/
|
2007-10-24 23:23:48 +07:00
|
|
|
void __sched wait_for_completion(struct completion *x)
|
2007-10-15 22:00:14 +07:00
|
|
|
{
|
|
|
|
wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-10-15 22:00:14 +07:00
|
|
|
EXPORT_SYMBOL(wait_for_completion);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* wait_for_completion_timeout: - waits for completion of a task (w/timeout)
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
* @timeout: timeout value in jiffies
|
|
|
|
*
|
|
|
|
* This waits for either a completion of a specific task to be signaled or for a
|
|
|
|
* specified timeout to expire. The timeout is in jiffies. It is not
|
|
|
|
* interruptible.
|
|
|
|
*/
|
2007-10-24 23:23:48 +07:00
|
|
|
unsigned long __sched
|
2007-10-15 22:00:14 +07:00
|
|
|
wait_for_completion_timeout(struct completion *x, unsigned long timeout)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:14 +07:00
|
|
|
return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-10-15 22:00:14 +07:00
|
|
|
EXPORT_SYMBOL(wait_for_completion_timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* wait_for_completion_interruptible: - waits for completion of a task (w/intr)
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
*
|
|
|
|
* This waits for completion of a specific task to be signaled. It is
|
|
|
|
* interruptible.
|
|
|
|
*/
|
2007-10-15 22:00:14 +07:00
|
|
|
int __sched wait_for_completion_interruptible(struct completion *x)
|
2007-07-09 23:52:01 +07:00
|
|
|
{
|
2007-10-19 02:32:55 +07:00
|
|
|
long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
|
|
|
|
if (t == -ERESTARTSYS)
|
|
|
|
return t;
|
|
|
|
return 0;
|
2007-07-09 23:52:01 +07:00
|
|
|
}
|
2007-10-15 22:00:14 +07:00
|
|
|
EXPORT_SYMBOL(wait_for_completion_interruptible);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* wait_for_completion_interruptible_timeout: - waits for completion (w/(to,intr))
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
* @timeout: timeout value in jiffies
|
|
|
|
*
|
|
|
|
* This waits for either a completion of a specific task to be signaled or for a
|
|
|
|
* specified timeout to expire. It is interruptible. The timeout is in jiffies.
|
|
|
|
*/
|
2007-10-24 23:23:48 +07:00
|
|
|
unsigned long __sched
|
2007-10-15 22:00:14 +07:00
|
|
|
wait_for_completion_interruptible_timeout(struct completion *x,
|
|
|
|
unsigned long timeout)
|
2007-07-09 23:52:01 +07:00
|
|
|
{
|
2007-10-15 22:00:14 +07:00
|
|
|
return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
|
2007-07-09 23:52:01 +07:00
|
|
|
}
|
2007-10-15 22:00:14 +07:00
|
|
|
EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-26 15:26:54 +07:00
|
|
|
/**
|
|
|
|
* wait_for_completion_killable: - waits for completion of a task (killable)
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
*
|
|
|
|
* This waits to be signaled for completion of a specific task. It can be
|
|
|
|
* interrupted by a kill signal.
|
|
|
|
*/
|
2007-12-07 00:29:54 +07:00
|
|
|
int __sched wait_for_completion_killable(struct completion *x)
|
|
|
|
{
|
|
|
|
long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
|
|
|
|
if (t == -ERESTARTSYS)
|
|
|
|
return t;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(wait_for_completion_killable);
|
|
|
|
|
2010-05-29 23:12:30 +07:00
|
|
|
/**
|
|
|
|
* wait_for_completion_killable_timeout: - waits for completion of a task (w/(to,killable))
|
|
|
|
* @x: holds the state of this particular completion
|
|
|
|
* @timeout: timeout value in jiffies
|
|
|
|
*
|
|
|
|
* This waits for either a completion of a specific task to be
|
|
|
|
* signaled or for a specified timeout to expire. It can be
|
|
|
|
* interrupted by a kill signal. The timeout is in jiffies.
|
|
|
|
*/
|
|
|
|
unsigned long __sched
|
|
|
|
wait_for_completion_killable_timeout(struct completion *x,
|
|
|
|
unsigned long timeout)
|
|
|
|
{
|
|
|
|
return wait_for_common(x, timeout, TASK_KILLABLE);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(wait_for_completion_killable_timeout);
|
|
|
|
|
2008-08-15 14:40:44 +07:00
|
|
|
/**
|
|
|
|
* try_wait_for_completion - try to decrement a completion without blocking
|
|
|
|
* @x: completion structure
|
|
|
|
*
|
|
|
|
* Returns: 0 if a decrement cannot be done without blocking
|
|
|
|
* 1 if a decrement succeeded.
|
|
|
|
*
|
|
|
|
* If a completion is being used as a counting completion,
|
|
|
|
* attempt to decrement the counter without blocking. This
|
|
|
|
* enables us to avoid waiting if the resource the completion
|
|
|
|
* is protecting is not available.
|
|
|
|
*/
|
|
|
|
bool try_wait_for_completion(struct completion *x)
|
|
|
|
{
|
2009-12-13 06:07:30 +07:00
|
|
|
unsigned long flags;
|
2008-08-15 14:40:44 +07:00
|
|
|
int ret = 1;
|
|
|
|
|
2009-12-13 06:07:30 +07:00
|
|
|
spin_lock_irqsave(&x->wait.lock, flags);
|
2008-08-15 14:40:44 +07:00
|
|
|
if (!x->done)
|
|
|
|
ret = 0;
|
|
|
|
else
|
|
|
|
x->done--;
|
2009-12-13 06:07:30 +07:00
|
|
|
spin_unlock_irqrestore(&x->wait.lock, flags);
|
2008-08-15 14:40:44 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(try_wait_for_completion);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* completion_done - Test to see if a completion has any waiters
|
|
|
|
* @x: completion structure
|
|
|
|
*
|
|
|
|
* Returns: 0 if there are waiters (wait_for_completion() in progress)
|
|
|
|
* 1 if there are no waiters.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
bool completion_done(struct completion *x)
|
|
|
|
{
|
2009-12-13 06:07:30 +07:00
|
|
|
unsigned long flags;
|
2008-08-15 14:40:44 +07:00
|
|
|
int ret = 1;
|
|
|
|
|
2009-12-13 06:07:30 +07:00
|
|
|
spin_lock_irqsave(&x->wait.lock, flags);
|
2008-08-15 14:40:44 +07:00
|
|
|
if (!x->done)
|
|
|
|
ret = 0;
|
2009-12-13 06:07:30 +07:00
|
|
|
spin_unlock_irqrestore(&x->wait.lock, flags);
|
2008-08-15 14:40:44 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(completion_done);
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
static long __sched
|
|
|
|
sleep_on_common(wait_queue_head_t *q, int state, long timeout)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-07-09 23:52:01 +07:00
|
|
|
unsigned long flags;
|
|
|
|
wait_queue_t wait;
|
|
|
|
|
|
|
|
init_waitqueue_entry(&wait, current);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
__set_current_state(state);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
spin_lock_irqsave(&q->lock, flags);
|
|
|
|
__add_wait_queue(q, &wait);
|
|
|
|
spin_unlock(&q->lock);
|
|
|
|
timeout = schedule_timeout(timeout);
|
|
|
|
spin_lock_irq(&q->lock);
|
|
|
|
__remove_wait_queue(q, &wait);
|
|
|
|
spin_unlock_irqrestore(&q->lock, flags);
|
|
|
|
|
|
|
|
return timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __sched interruptible_sleep_on(wait_queue_head_t *q)
|
|
|
|
{
|
|
|
|
sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(interruptible_sleep_on);
|
|
|
|
|
2007-07-09 23:52:01 +07:00
|
|
|
long __sched
|
2005-09-10 14:26:11 +07:00
|
|
|
interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:14 +07:00
|
|
|
return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(interruptible_sleep_on_timeout);
|
|
|
|
|
2007-07-09 23:52:01 +07:00
|
|
|
void __sched sleep_on(wait_queue_head_t *q)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:14 +07:00
|
|
|
sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sleep_on);
|
|
|
|
|
2007-07-09 23:52:01 +07:00
|
|
|
long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:14 +07:00
|
|
|
return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(sleep_on_timeout);
|
|
|
|
|
2006-06-27 16:54:51 +07:00
|
|
|
#ifdef CONFIG_RT_MUTEXES
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rt_mutex_setprio - set the current priority of a task
|
|
|
|
* @p: task
|
|
|
|
* @prio: prio value (kernel-internal form)
|
|
|
|
*
|
|
|
|
* This function changes the 'effective' priority of a task. It does
|
|
|
|
* not touch ->normal_prio like __setscheduler().
|
|
|
|
*
|
|
|
|
* Used by the rt_mutex code to implement priority inheritance logic.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
void rt_mutex_setprio(struct task_struct *p, int prio)
|
2006-06-27 16:54:51 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-10-15 22:00:08 +07:00
|
|
|
int oldprio, on_rq, running;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2010-02-17 15:05:48 +07:00
|
|
|
const struct sched_class *prev_class;
|
2006-06-27 16:54:51 +07:00
|
|
|
|
|
|
|
BUG_ON(prio < 0 || prio > MAX_PRIO);
|
|
|
|
|
|
|
|
rq = task_rq_lock(p, &flags);
|
|
|
|
|
2007-05-09 10:27:06 +07:00
|
|
|
oldprio = p->prio;
|
2010-02-17 15:05:48 +07:00
|
|
|
prev_class = p->sched_class;
|
2007-07-09 23:51:59 +07:00
|
|
|
on_rq = p->se.on_rq;
|
2007-12-18 21:21:13 +07:00
|
|
|
running = task_current(rq, p);
|
2008-03-11 01:01:20 +07:00
|
|
|
if (on_rq)
|
2007-08-09 16:16:49 +07:00
|
|
|
dequeue_task(rq, p, 0);
|
2008-03-11 01:01:20 +07:00
|
|
|
if (running)
|
|
|
|
p->sched_class->put_prev_task(rq, p);
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
if (rt_prio(prio))
|
|
|
|
p->sched_class = &rt_sched_class;
|
|
|
|
else
|
|
|
|
p->sched_class = &fair_sched_class;
|
|
|
|
|
2006-06-27 16:54:51 +07:00
|
|
|
p->prio = prio;
|
|
|
|
|
2008-03-11 01:01:20 +07:00
|
|
|
if (running)
|
|
|
|
p->sched_class->set_curr_task(rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
if (on_rq) {
|
2010-03-24 22:38:48 +07:00
|
|
|
enqueue_task(rq, p, oldprio < prio ? ENQUEUE_HEAD : 0);
|
2008-01-26 03:08:22 +07:00
|
|
|
|
|
|
|
check_class_changed(rq, p, prev_class, oldprio, running);
|
2006-06-27 16:54:51 +07:00
|
|
|
}
|
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2006-07-03 14:25:41 +07:00
|
|
|
void set_user_nice(struct task_struct *p, long nice)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-07-09 23:51:59 +07:00
|
|
|
int old_prio, delta, on_rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (TASK_NICE(p) == nice || nice < -20 || nice > 19)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* We have to be careful, if called from sys_setpriority(),
|
|
|
|
* the task might be in the middle of scheduling on another CPU.
|
|
|
|
*/
|
|
|
|
rq = task_rq_lock(p, &flags);
|
|
|
|
/*
|
|
|
|
* The RT priorities are set via sched_setscheduler(), but we still
|
|
|
|
* allow the 'normal' nice value to be set - but as expected
|
|
|
|
* it wont have any effect on scheduling until the task is
|
2007-07-09 23:51:59 +07:00
|
|
|
* SCHED_FIFO/SCHED_RR:
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-07-09 23:51:59 +07:00
|
|
|
if (task_has_rt_policy(p)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
p->static_prio = NICE_TO_PRIO(nice);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
on_rq = p->se.on_rq;
|
2008-06-27 18:41:14 +07:00
|
|
|
if (on_rq)
|
2007-08-09 16:16:49 +07:00
|
|
|
dequeue_task(rq, p, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
p->static_prio = NICE_TO_PRIO(nice);
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
set_load_weight(p);
|
2006-06-27 16:54:51 +07:00
|
|
|
old_prio = p->prio;
|
|
|
|
p->prio = effective_prio(p);
|
|
|
|
delta = p->prio - old_prio;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
if (on_rq) {
|
2010-03-24 22:38:48 +07:00
|
|
|
enqueue_task(rq, p, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2007-05-09 10:27:06 +07:00
|
|
|
* If the task increased its priority or is running and
|
|
|
|
* lowered its priority, then reschedule its CPU:
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-05-09 10:27:06 +07:00
|
|
|
if (delta < 0 || (delta > 0 && task_running(rq, p)))
|
2005-04-17 05:20:36 +07:00
|
|
|
resched_task(rq->curr);
|
|
|
|
}
|
|
|
|
out_unlock:
|
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(set_user_nice);
|
|
|
|
|
2005-05-01 22:59:00 +07:00
|
|
|
/*
|
|
|
|
* can_nice - check if a task can reduce its nice value
|
|
|
|
* @p: task
|
|
|
|
* @nice: nice value
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
int can_nice(const struct task_struct *p, const int nice)
|
2005-05-01 22:59:00 +07:00
|
|
|
{
|
2005-08-19 01:24:19 +07:00
|
|
|
/* convert nice value [19,-20] to rlimit style value [1,40] */
|
|
|
|
int nice_rlim = 20 - nice;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2010-03-06 04:42:54 +07:00
|
|
|
return (nice_rlim <= task_rlimit(p, RLIMIT_NICE) ||
|
2005-05-01 22:59:00 +07:00
|
|
|
capable(CAP_SYS_NICE));
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef __ARCH_WANT_SYS_NICE
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sys_nice - change the priority of the current process.
|
|
|
|
* @increment: priority increment
|
|
|
|
*
|
|
|
|
* sys_setpriority is a more generic, but much slower function that
|
|
|
|
* does similar things.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE1(nice, int, increment)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:40 +07:00
|
|
|
long nice, retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Setpriority might change our priority at the same moment.
|
|
|
|
* We don't have to worry. Conceptually one call occurs first
|
|
|
|
* and we have a single winner.
|
|
|
|
*/
|
2005-05-01 22:59:00 +07:00
|
|
|
if (increment < -40)
|
|
|
|
increment = -40;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (increment > 40)
|
|
|
|
increment = 40;
|
|
|
|
|
2009-02-16 17:54:21 +07:00
|
|
|
nice = TASK_NICE(current) + increment;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (nice < -20)
|
|
|
|
nice = -20;
|
|
|
|
if (nice > 19)
|
|
|
|
nice = 19;
|
|
|
|
|
2005-05-01 22:59:00 +07:00
|
|
|
if (increment < 0 && !can_nice(current, nice))
|
|
|
|
return -EPERM;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = security_task_setnice(current, nice);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
set_user_nice(current, nice);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* task_prio - return the priority value of a given task.
|
|
|
|
* @p: the task in question.
|
|
|
|
*
|
|
|
|
* This is the priority value as seen by users in /proc.
|
|
|
|
* RT tasks are offset by -200. Normal tasks are centered
|
|
|
|
* around 0, value goes from -16 to +15.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
int task_prio(const struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return p->prio - MAX_RT_PRIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* task_nice - return the nice value of a given task.
|
|
|
|
* @p: the task in question.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
int task_nice(const struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return TASK_NICE(p);
|
|
|
|
}
|
2008-03-06 04:56:37 +07:00
|
|
|
EXPORT_SYMBOL(task_nice);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* idle_cpu - is a given cpu idle currently?
|
|
|
|
* @cpu: the processor in question.
|
|
|
|
*/
|
|
|
|
int idle_cpu(int cpu)
|
|
|
|
{
|
|
|
|
return cpu_curr(cpu) == cpu_rq(cpu)->idle;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* idle_task - return the idle task for a given cpu.
|
|
|
|
* @cpu: the processor in question.
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *idle_task(int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return cpu_rq(cpu)->idle;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* find_process_by_pid - find a process with a matching PID value.
|
|
|
|
* @pid: the pid in question.
|
|
|
|
*/
|
2007-10-15 22:00:13 +07:00
|
|
|
static struct task_struct *find_process_by_pid(pid_t pid)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-19 13:40:16 +07:00
|
|
|
return pid ? find_task_by_vpid(pid) : current;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Actually do priority change: must hold rq lock. */
|
2007-07-09 23:51:59 +07:00
|
|
|
static void
|
|
|
|
__setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-07-09 23:51:59 +07:00
|
|
|
BUG_ON(p->se.on_rq);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
p->policy = policy;
|
|
|
|
p->rt_priority = prio;
|
2006-06-27 16:54:51 +07:00
|
|
|
p->normal_prio = normal_prio(p);
|
|
|
|
/* we are holding p->pi_lock already */
|
|
|
|
p->prio = rt_mutex_getprio(p);
|
2009-11-11 02:12:01 +07:00
|
|
|
if (rt_prio(p->prio))
|
|
|
|
p->sched_class = &rt_sched_class;
|
|
|
|
else
|
|
|
|
p->sched_class = &fair_sched_class;
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
set_load_weight(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-11-14 06:39:19 +07:00
|
|
|
/*
|
|
|
|
* check the target process has a UID that matches the current process's
|
|
|
|
*/
|
|
|
|
static bool check_same_owner(struct task_struct *p)
|
|
|
|
{
|
|
|
|
const struct cred *cred = current_cred(), *pcred;
|
|
|
|
bool match;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
pcred = __task_cred(p);
|
|
|
|
match = (cred->euid == pcred->euid ||
|
|
|
|
cred->euid == pcred->uid);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
|
2008-06-23 10:55:38 +07:00
|
|
|
static int __sched_setscheduler(struct task_struct *p, int policy,
|
|
|
|
struct sched_param *param, bool user)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-15 22:00:08 +07:00
|
|
|
int retval, oldprio, oldpolicy = -1, on_rq, running;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
2010-02-17 15:05:48 +07:00
|
|
|
const struct sched_class *prev_class;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2009-06-15 22:17:47 +07:00
|
|
|
int reset_on_fork;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 16:54:44 +07:00
|
|
|
/* may grab non-irq protected spin_locks */
|
|
|
|
BUG_ON(in_interrupt());
|
2005-04-17 05:20:36 +07:00
|
|
|
recheck:
|
|
|
|
/* double check policy once rq lock held */
|
2009-06-15 22:17:47 +07:00
|
|
|
if (policy < 0) {
|
|
|
|
reset_on_fork = p->sched_reset_on_fork;
|
2005-04-17 05:20:36 +07:00
|
|
|
policy = oldpolicy = p->policy;
|
2009-06-15 22:17:47 +07:00
|
|
|
} else {
|
|
|
|
reset_on_fork = !!(policy & SCHED_RESET_ON_FORK);
|
|
|
|
policy &= ~SCHED_RESET_ON_FORK;
|
|
|
|
|
|
|
|
if (policy != SCHED_FIFO && policy != SCHED_RR &&
|
|
|
|
policy != SCHED_NORMAL && policy != SCHED_BATCH &&
|
|
|
|
policy != SCHED_IDLE)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Valid priorities for SCHED_FIFO and SCHED_RR are
|
2007-07-09 23:51:59 +07:00
|
|
|
* 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL,
|
|
|
|
* SCHED_BATCH and SCHED_IDLE is 0.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
if (param->sched_priority < 0 ||
|
2005-09-10 14:26:11 +07:00
|
|
|
(p->mm && param->sched_priority > MAX_USER_RT_PRIO-1) ||
|
2005-07-26 03:28:39 +07:00
|
|
|
(!p->mm && param->sched_priority > MAX_RT_PRIO-1))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
2007-07-09 23:51:59 +07:00
|
|
|
if (rt_policy(policy) != (param->sched_priority != 0))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
[PATCH] Changing RT priority without CAP_SYS_NICE
Presently, a process without the capability CAP_SYS_NICE can not change
its own policy, which is OK.
But it can also not decrease its RT priority (if scheduled with policy
SCHED_RR or SCHED_FIFO), which is what this patch changes.
The rationale is the same as for the nice value: a process should be
able to require less priority for itself. Increasing the priority is
still not allowed.
This is for example useful if you give a multithreaded user process a RT
priority, and the process would like to organize its internal threads
using priorities also. Then you can give the process the highest
priority needed N, and the process starts its threads with lower
priorities: N-1, N-2...
The POSIX norm says that the permissions are implementation specific, so
I think we can do that.
In a sense, it makes the permissions consistent whatever the policy is:
with this patch, process scheduled by SCHED_FIFO, SCHED_RR and
SCHED_OTHER can all decrease their priority.
From: Ingo Molnar <mingo@elte.hu>
cleaned up and merged to -mm.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 04:57:32 +07:00
|
|
|
/*
|
|
|
|
* Allow unprivileged RT tasks to decrease priority:
|
|
|
|
*/
|
2008-06-23 10:55:38 +07:00
|
|
|
if (user && !capable(CAP_SYS_NICE)) {
|
2007-07-09 23:51:59 +07:00
|
|
|
if (rt_policy(policy)) {
|
2006-09-29 16:00:50 +07:00
|
|
|
unsigned long rlim_rtprio;
|
|
|
|
|
|
|
|
if (!lock_task_sighand(p, &flags))
|
|
|
|
return -ESRCH;
|
2010-03-06 04:42:54 +07:00
|
|
|
rlim_rtprio = task_rlimit(p, RLIMIT_RTPRIO);
|
2006-09-29 16:00:50 +07:00
|
|
|
unlock_task_sighand(p, &flags);
|
|
|
|
|
|
|
|
/* can't set/change the rt policy */
|
|
|
|
if (policy != p->policy && !rlim_rtprio)
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/* can't increase priority */
|
|
|
|
if (param->sched_priority > p->rt_priority &&
|
|
|
|
param->sched_priority > rlim_rtprio)
|
|
|
|
return -EPERM;
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* Like positive nice levels, dont allow tasks to
|
|
|
|
* move out of SCHED_IDLE either:
|
|
|
|
*/
|
|
|
|
if (p->policy == SCHED_IDLE && policy != SCHED_IDLE)
|
|
|
|
return -EPERM;
|
2006-09-29 16:00:48 +07:00
|
|
|
|
[PATCH] Changing RT priority without CAP_SYS_NICE
Presently, a process without the capability CAP_SYS_NICE can not change
its own policy, which is OK.
But it can also not decrease its RT priority (if scheduled with policy
SCHED_RR or SCHED_FIFO), which is what this patch changes.
The rationale is the same as for the nice value: a process should be
able to require less priority for itself. Increasing the priority is
still not allowed.
This is for example useful if you give a multithreaded user process a RT
priority, and the process would like to organize its internal threads
using priorities also. Then you can give the process the highest
priority needed N, and the process starts its threads with lower
priorities: N-1, N-2...
The POSIX norm says that the permissions are implementation specific, so
I think we can do that.
In a sense, it makes the permissions consistent whatever the policy is:
with this patch, process scheduled by SCHED_FIFO, SCHED_RR and
SCHED_OTHER can all decrease their priority.
From: Ingo Molnar <mingo@elte.hu>
cleaned up and merged to -mm.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 04:57:32 +07:00
|
|
|
/* can't change other user's priorities */
|
2008-11-14 06:39:19 +07:00
|
|
|
if (!check_same_owner(p))
|
[PATCH] Changing RT priority without CAP_SYS_NICE
Presently, a process without the capability CAP_SYS_NICE can not change
its own policy, which is OK.
But it can also not decrease its RT priority (if scheduled with policy
SCHED_RR or SCHED_FIFO), which is what this patch changes.
The rationale is the same as for the nice value: a process should be
able to require less priority for itself. Increasing the priority is
still not allowed.
This is for example useful if you give a multithreaded user process a RT
priority, and the process would like to organize its internal threads
using priorities also. Then you can give the process the highest
priority needed N, and the process starts its threads with lower
priorities: N-1, N-2...
The POSIX norm says that the permissions are implementation specific, so
I think we can do that.
In a sense, it makes the permissions consistent whatever the policy is:
with this patch, process scheduled by SCHED_FIFO, SCHED_RR and
SCHED_OTHER can all decrease their priority.
From: Ingo Molnar <mingo@elte.hu>
cleaned up and merged to -mm.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 04:57:32 +07:00
|
|
|
return -EPERM;
|
2009-06-15 22:17:47 +07:00
|
|
|
|
|
|
|
/* Normal users shall not reset the sched_reset_on_fork flag */
|
|
|
|
if (p->sched_reset_on_fork && !reset_on_fork)
|
|
|
|
return -EPERM;
|
[PATCH] Changing RT priority without CAP_SYS_NICE
Presently, a process without the capability CAP_SYS_NICE can not change
its own policy, which is OK.
But it can also not decrease its RT priority (if scheduled with policy
SCHED_RR or SCHED_FIFO), which is what this patch changes.
The rationale is the same as for the nice value: a process should be
able to require less priority for itself. Increasing the priority is
still not allowed.
This is for example useful if you give a multithreaded user process a RT
priority, and the process would like to organize its internal threads
using priorities also. Then you can give the process the highest
priority needed N, and the process starts its threads with lower
priorities: N-1, N-2...
The POSIX norm says that the permissions are implementation specific, so
I think we can do that.
In a sense, it makes the permissions consistent whatever the policy is:
with this patch, process scheduled by SCHED_FIFO, SCHED_RR and
SCHED_OTHER can all decrease their priority.
From: Ingo Molnar <mingo@elte.hu>
cleaned up and merged to -mm.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 04:57:32 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-03 23:33:03 +07:00
|
|
|
if (user) {
|
|
|
|
retval = security_task_setscheduler(p, policy, param);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2006-06-27 16:54:51 +07:00
|
|
|
/*
|
|
|
|
* make sure no PI-waiters arrive (or leave) while we are
|
|
|
|
* changing the priority of the task:
|
|
|
|
*/
|
2009-11-17 20:54:03 +07:00
|
|
|
raw_spin_lock_irqsave(&p->pi_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* To be able to change p->policy safely, the apropriate
|
|
|
|
* runqueue lock must be held.
|
|
|
|
*/
|
2006-06-27 16:54:51 +07:00
|
|
|
rq = __task_rq_lock(p);
|
2010-06-08 16:40:42 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
if (user) {
|
|
|
|
/*
|
|
|
|
* Do not allow realtime tasks into groups that have no runtime
|
|
|
|
* assigned.
|
|
|
|
*/
|
|
|
|
if (rt_bandwidth_enabled() && rt_policy(policy) &&
|
|
|
|
task_group(p)->rt_bandwidth.rt_runtime == 0) {
|
|
|
|
__task_rq_unlock(rq);
|
|
|
|
raw_spin_unlock_irqrestore(&p->pi_lock, flags);
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* recheck policy now with rq lock held */
|
|
|
|
if (unlikely(oldpolicy != -1 && oldpolicy != p->policy)) {
|
|
|
|
policy = oldpolicy = -1;
|
2006-06-27 16:54:51 +07:00
|
|
|
__task_rq_unlock(rq);
|
2009-11-17 20:54:03 +07:00
|
|
|
raw_spin_unlock_irqrestore(&p->pi_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto recheck;
|
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
on_rq = p->se.on_rq;
|
2007-12-18 21:21:13 +07:00
|
|
|
running = task_current(rq, p);
|
2008-03-11 01:01:20 +07:00
|
|
|
if (on_rq)
|
2007-08-09 16:16:49 +07:00
|
|
|
deactivate_task(rq, p, 0);
|
2008-03-11 01:01:20 +07:00
|
|
|
if (running)
|
|
|
|
p->sched_class->put_prev_task(rq, p);
|
2007-10-15 22:00:08 +07:00
|
|
|
|
2009-06-15 22:17:47 +07:00
|
|
|
p->sched_reset_on_fork = reset_on_fork;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
oldprio = p->prio;
|
2010-02-17 15:05:48 +07:00
|
|
|
prev_class = p->sched_class;
|
2007-07-09 23:51:59 +07:00
|
|
|
__setscheduler(rq, p, policy, param->sched_priority);
|
2007-10-15 22:00:08 +07:00
|
|
|
|
2008-03-11 01:01:20 +07:00
|
|
|
if (running)
|
|
|
|
p->sched_class->set_curr_task(rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
if (on_rq) {
|
|
|
|
activate_task(rq, p, 0);
|
2008-01-26 03:08:22 +07:00
|
|
|
|
|
|
|
check_class_changed(rq, p, prev_class, oldprio, running);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-27 16:54:51 +07:00
|
|
|
__task_rq_unlock(rq);
|
2009-11-17 20:54:03 +07:00
|
|
|
raw_spin_unlock_irqrestore(&p->pi_lock, flags);
|
2006-06-27 16:54:51 +07:00
|
|
|
|
2006-06-27 16:55:02 +07:00
|
|
|
rt_mutex_adjust_pi(p);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-06-23 10:55:38 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
|
|
|
|
* @p: the task in question.
|
|
|
|
* @policy: new policy.
|
|
|
|
* @param: structure containing the new RT priority.
|
|
|
|
*
|
|
|
|
* NOTE that the task may be already dead.
|
|
|
|
*/
|
|
|
|
int sched_setscheduler(struct task_struct *p, int policy,
|
|
|
|
struct sched_param *param)
|
|
|
|
{
|
|
|
|
return __sched_setscheduler(p, policy, param, true);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
EXPORT_SYMBOL_GPL(sched_setscheduler);
|
|
|
|
|
2008-06-23 10:55:38 +07:00
|
|
|
/**
|
|
|
|
* sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
|
|
|
|
* @p: the task in question.
|
|
|
|
* @policy: new policy.
|
|
|
|
* @param: structure containing the new RT priority.
|
|
|
|
*
|
|
|
|
* Just like sched_setscheduler, only don't bother checking if the
|
|
|
|
* current context has permission. For example, this is needed in
|
|
|
|
* stop_machine(): we create temporary high priority worker threads,
|
|
|
|
* but our caller might not have that capability.
|
|
|
|
*/
|
|
|
|
int sched_setscheduler_nocheck(struct task_struct *p, int policy,
|
|
|
|
struct sched_param *param)
|
|
|
|
{
|
|
|
|
return __sched_setscheduler(p, policy, param, false);
|
|
|
|
}
|
|
|
|
|
2005-09-10 14:26:11 +07:00
|
|
|
static int
|
|
|
|
do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sched_param lparam;
|
|
|
|
struct task_struct *p;
|
2006-07-03 14:25:41 +07:00
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!param || pid < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(&lparam, param, sizeof(struct sched_param)))
|
|
|
|
return -EFAULT;
|
2006-09-29 16:00:48 +07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
retval = -ESRCH;
|
2005-04-17 05:20:36 +07:00
|
|
|
p = find_process_by_pid(pid);
|
2006-09-29 16:00:48 +07:00
|
|
|
if (p != NULL)
|
|
|
|
retval = sched_setscheduler(p, policy, &lparam);
|
|
|
|
rcu_read_unlock();
|
2006-07-03 14:25:41 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_setscheduler - set/change the scheduler policy and RT priority
|
|
|
|
* @pid: the pid in question.
|
|
|
|
* @policy: new policy.
|
|
|
|
* @param: structure containing the new RT priority.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy,
|
|
|
|
struct sched_param __user *, param)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-01-19 08:43:03 +07:00
|
|
|
/* negative values for policy are not valid */
|
|
|
|
if (policy < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return do_sched_setscheduler(pid, policy, param);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_setparam - set/change the RT priority of a thread
|
|
|
|
* @pid: the pid in question.
|
|
|
|
* @param: structure containing the new RT priority.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return do_sched_setscheduler(pid, -1, param);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_getscheduler - get the policy (scheduling class) of a thread
|
|
|
|
* @pid: the pid in question.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *p;
|
2007-10-15 22:00:14 +07:00
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (pid < 0)
|
2007-10-15 22:00:14 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = -ESRCH;
|
2009-12-09 17:14:58 +07:00
|
|
|
rcu_read_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
p = find_process_by_pid(pid);
|
|
|
|
if (p) {
|
|
|
|
retval = security_task_getscheduler(p);
|
|
|
|
if (!retval)
|
2009-06-15 22:17:47 +07:00
|
|
|
retval = p->policy
|
|
|
|
| (p->sched_reset_on_fork ? SCHED_RESET_ON_FORK : 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-12-09 17:14:58 +07:00
|
|
|
rcu_read_unlock();
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-06-15 22:17:47 +07:00
|
|
|
* sys_sched_getparam - get the RT priority of a thread
|
2005-04-17 05:20:36 +07:00
|
|
|
* @pid: the pid in question.
|
|
|
|
* @param: structure containing the RT priority.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sched_param lp;
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *p;
|
2007-10-15 22:00:14 +07:00
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!param || pid < 0)
|
2007-10-15 22:00:14 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-12-09 17:14:58 +07:00
|
|
|
rcu_read_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
p = find_process_by_pid(pid);
|
|
|
|
retval = -ESRCH;
|
|
|
|
if (!p)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
retval = security_task_getscheduler(p);
|
|
|
|
if (retval)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
lp.sched_priority = p->rt_priority;
|
2009-12-09 17:14:58 +07:00
|
|
|
rcu_read_unlock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This one might sleep, we cannot do it with a spinlock held ...
|
|
|
|
*/
|
|
|
|
retval = copy_to_user(param, &lp, sizeof(*param)) ? -EFAULT : 0;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
out_unlock:
|
2009-12-09 17:14:58 +07:00
|
|
|
rcu_read_unlock();
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-11-24 23:05:11 +07:00
|
|
|
cpumask_var_t cpus_allowed, new_mask;
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *p;
|
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-26 03:08:02 +07:00
|
|
|
get_online_cpus();
|
2009-12-09 17:15:01 +07:00
|
|
|
rcu_read_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
p = find_process_by_pid(pid);
|
|
|
|
if (!p) {
|
2009-12-09 17:15:01 +07:00
|
|
|
rcu_read_unlock();
|
2008-01-26 03:08:02 +07:00
|
|
|
put_online_cpus();
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ESRCH;
|
|
|
|
}
|
|
|
|
|
2009-12-09 17:15:01 +07:00
|
|
|
/* Prevent p going away */
|
2005-04-17 05:20:36 +07:00
|
|
|
get_task_struct(p);
|
2009-12-09 17:15:01 +07:00
|
|
|
rcu_read_unlock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL)) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto out_put_task;
|
|
|
|
}
|
|
|
|
if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto out_free_cpus_allowed;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = -EPERM;
|
2008-11-14 06:39:19 +07:00
|
|
|
if (!check_same_owner(p) && !capable(CAP_SYS_NICE))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out_unlock;
|
|
|
|
|
2006-06-23 16:03:59 +07:00
|
|
|
retval = security_task_setscheduler(p, 0, NULL);
|
|
|
|
if (retval)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
cpuset_cpus_allowed(p, cpus_allowed);
|
|
|
|
cpumask_and(new_mask, in_mask, cpus_allowed);
|
2007-10-19 13:40:22 +07:00
|
|
|
again:
|
2008-11-24 23:05:11 +07:00
|
|
|
retval = set_cpus_allowed_ptr(p, new_mask);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-19 13:40:22 +07:00
|
|
|
if (!retval) {
|
2008-11-24 23:05:11 +07:00
|
|
|
cpuset_cpus_allowed(p, cpus_allowed);
|
|
|
|
if (!cpumask_subset(new_mask, cpus_allowed)) {
|
2007-10-19 13:40:22 +07:00
|
|
|
/*
|
|
|
|
* We must have raced with a concurrent cpuset
|
|
|
|
* update. Just reset the cpus_allowed to the
|
|
|
|
* cpuset's cpus_allowed
|
|
|
|
*/
|
2008-11-24 23:05:11 +07:00
|
|
|
cpumask_copy(new_mask, cpus_allowed);
|
2007-10-19 13:40:22 +07:00
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
out_unlock:
|
2008-11-24 23:05:11 +07:00
|
|
|
free_cpumask_var(new_mask);
|
|
|
|
out_free_cpus_allowed:
|
|
|
|
free_cpumask_var(cpus_allowed);
|
|
|
|
out_put_task:
|
2005-04-17 05:20:36 +07:00
|
|
|
put_task_struct(p);
|
2008-01-26 03:08:02 +07:00
|
|
|
put_online_cpus();
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
|
2008-11-24 23:05:14 +07:00
|
|
|
struct cpumask *new_mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-11-24 23:05:14 +07:00
|
|
|
if (len < cpumask_size())
|
|
|
|
cpumask_clear(new_mask);
|
|
|
|
else if (len > cpumask_size())
|
|
|
|
len = cpumask_size();
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_setaffinity - set the cpu affinity of a process
|
|
|
|
* @pid: pid of the process
|
|
|
|
* @len: length in bytes of the bitmask pointed to by user_mask_ptr
|
|
|
|
* @user_mask_ptr: user-space pointer to the new cpu mask
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
|
|
|
|
unsigned long __user *, user_mask_ptr)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-11-24 23:05:11 +07:00
|
|
|
cpumask_var_t new_mask;
|
2005-04-17 05:20:36 +07:00
|
|
|
int retval;
|
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
|
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
retval = get_user_cpu_mask(user_mask_ptr, len, new_mask);
|
|
|
|
if (retval == 0)
|
|
|
|
retval = sched_setaffinity(pid, new_mask);
|
|
|
|
free_cpumask_var(new_mask);
|
|
|
|
return retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
long sched_getaffinity(pid_t pid, struct cpumask *mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *p;
|
2009-12-09 03:24:16 +07:00
|
|
|
unsigned long flags;
|
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
int retval;
|
|
|
|
|
2008-01-26 03:08:02 +07:00
|
|
|
get_online_cpus();
|
2009-12-09 17:15:01 +07:00
|
|
|
rcu_read_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = -ESRCH;
|
|
|
|
p = find_process_by_pid(pid);
|
|
|
|
if (!p)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2006-06-23 16:03:59 +07:00
|
|
|
retval = security_task_getscheduler(p);
|
|
|
|
if (retval)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2009-12-09 03:24:16 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
2008-11-24 23:05:14 +07:00
|
|
|
cpumask_and(mask, &p->cpus_allowed, cpu_online_mask);
|
2009-12-09 03:24:16 +07:00
|
|
|
task_rq_unlock(rq, &flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
out_unlock:
|
2009-12-09 17:15:01 +07:00
|
|
|
rcu_read_unlock();
|
2008-01-26 03:08:02 +07:00
|
|
|
put_online_cpus();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-09 16:16:46 +07:00
|
|
|
return retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_getaffinity - get the cpu affinity of a process
|
|
|
|
* @pid: pid of the process
|
|
|
|
* @len: length in bytes of the bitmask pointed to by user_mask_ptr
|
|
|
|
* @user_mask_ptr: user-space pointer to hold the current cpu mask
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
|
|
|
|
unsigned long __user *, user_mask_ptr)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int ret;
|
2008-11-24 23:05:11 +07:00
|
|
|
cpumask_var_t mask;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-04-06 14:02:19 +07:00
|
|
|
if ((len * BITS_PER_BYTE) < nr_cpu_ids)
|
sched: sched_getaffinity(): Allow less than NR_CPUS length
[ Note, this commit changes the syscall ABI for > 1024 CPUs systems. ]
Recently, some distro decided to use NR_CPUS=4096 for mysterious reasons.
Unfortunately, glibc sched interface has the following definition:
# define __CPU_SETSIZE 1024
# define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
typedef struct
{
__cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
} cpu_set_t;
It mean, if NR_CPUS is bigger than 1024, cpu_set_t makes an
ABI issue ...
More recently, Sharyathi Nagesh reported following test program makes
misterious syscall failure:
-----------------------------------------------------------------------
#define _GNU_SOURCE
#include<stdio.h>
#include<errno.h>
#include<sched.h>
int main()
{
cpu_set_t set;
if (sched_getaffinity(0, sizeof(cpu_set_t), &set) < 0)
printf("\n Call is failing with:%d", errno);
}
-----------------------------------------------------------------------
Because the kernel assumes len argument of sched_getaffinity() is bigger
than NR_CPUS. But now it is not correct.
Now we are faced with the following annoying dilemma, due to
the limitations of the glibc interface built in years ago:
(1) if we change glibc's __CPU_SETSIZE definition, we lost
binary compatibility of _all_ application.
(2) if we don't change it, we also lost binary compatibility of
Sharyathi's use case.
Then, I would propse to change the rule of the len argument of
sched_getaffinity().
Old:
len should be bigger than NR_CPUS
New:
len should be bigger than maximum possible cpu id
This creates the following behavior:
(A) In the real 4096 cpus machine, the above test program still
return -EINVAL.
(B) NR_CPUS=4096 but the machine have less than 1024 cpus (almost
all machines in the world), the above can run successfully.
Fortunatelly, BIG SGI machine is mainly used for HPC use case. It means
they can rebuild their programs.
IOW we hope they are not annoyed by this issue ...
Reported-by: Sharyathi Nagesh <sharyath@in.ibm.com>
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Acked-by: Ulrich Drepper <drepper@redhat.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Jack Steiner <steiner@sgi.com>
Cc: Russ Anderson <rja@sgi.com>
Cc: Mike Travis <travis@sgi.com>
LKML-Reference: <20100312161316.9520.A69D9226@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-03-12 14:15:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
if (len & (sizeof(unsigned long)-1))
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
if (!alloc_cpumask_var(&mask, GFP_KERNEL))
|
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
ret = sched_getaffinity(pid, mask);
|
|
|
|
if (ret == 0) {
|
2010-03-17 07:36:58 +07:00
|
|
|
size_t retlen = min_t(size_t, len, cpumask_size());
|
sched: sched_getaffinity(): Allow less than NR_CPUS length
[ Note, this commit changes the syscall ABI for > 1024 CPUs systems. ]
Recently, some distro decided to use NR_CPUS=4096 for mysterious reasons.
Unfortunately, glibc sched interface has the following definition:
# define __CPU_SETSIZE 1024
# define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
typedef struct
{
__cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
} cpu_set_t;
It mean, if NR_CPUS is bigger than 1024, cpu_set_t makes an
ABI issue ...
More recently, Sharyathi Nagesh reported following test program makes
misterious syscall failure:
-----------------------------------------------------------------------
#define _GNU_SOURCE
#include<stdio.h>
#include<errno.h>
#include<sched.h>
int main()
{
cpu_set_t set;
if (sched_getaffinity(0, sizeof(cpu_set_t), &set) < 0)
printf("\n Call is failing with:%d", errno);
}
-----------------------------------------------------------------------
Because the kernel assumes len argument of sched_getaffinity() is bigger
than NR_CPUS. But now it is not correct.
Now we are faced with the following annoying dilemma, due to
the limitations of the glibc interface built in years ago:
(1) if we change glibc's __CPU_SETSIZE definition, we lost
binary compatibility of _all_ application.
(2) if we don't change it, we also lost binary compatibility of
Sharyathi's use case.
Then, I would propse to change the rule of the len argument of
sched_getaffinity().
Old:
len should be bigger than NR_CPUS
New:
len should be bigger than maximum possible cpu id
This creates the following behavior:
(A) In the real 4096 cpus machine, the above test program still
return -EINVAL.
(B) NR_CPUS=4096 but the machine have less than 1024 cpus (almost
all machines in the world), the above can run successfully.
Fortunatelly, BIG SGI machine is mainly used for HPC use case. It means
they can rebuild their programs.
IOW we hope they are not annoyed by this issue ...
Reported-by: Sharyathi Nagesh <sharyath@in.ibm.com>
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Acked-by: Ulrich Drepper <drepper@redhat.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Jack Steiner <steiner@sgi.com>
Cc: Russ Anderson <rja@sgi.com>
Cc: Mike Travis <travis@sgi.com>
LKML-Reference: <20100312161316.9520.A69D9226@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-03-12 14:15:36 +07:00
|
|
|
|
|
|
|
if (copy_to_user(user_mask_ptr, mask, retlen))
|
2008-11-24 23:05:11 +07:00
|
|
|
ret = -EFAULT;
|
|
|
|
else
|
sched: sched_getaffinity(): Allow less than NR_CPUS length
[ Note, this commit changes the syscall ABI for > 1024 CPUs systems. ]
Recently, some distro decided to use NR_CPUS=4096 for mysterious reasons.
Unfortunately, glibc sched interface has the following definition:
# define __CPU_SETSIZE 1024
# define __NCPUBITS (8 * sizeof (__cpu_mask))
typedef unsigned long int __cpu_mask;
typedef struct
{
__cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
} cpu_set_t;
It mean, if NR_CPUS is bigger than 1024, cpu_set_t makes an
ABI issue ...
More recently, Sharyathi Nagesh reported following test program makes
misterious syscall failure:
-----------------------------------------------------------------------
#define _GNU_SOURCE
#include<stdio.h>
#include<errno.h>
#include<sched.h>
int main()
{
cpu_set_t set;
if (sched_getaffinity(0, sizeof(cpu_set_t), &set) < 0)
printf("\n Call is failing with:%d", errno);
}
-----------------------------------------------------------------------
Because the kernel assumes len argument of sched_getaffinity() is bigger
than NR_CPUS. But now it is not correct.
Now we are faced with the following annoying dilemma, due to
the limitations of the glibc interface built in years ago:
(1) if we change glibc's __CPU_SETSIZE definition, we lost
binary compatibility of _all_ application.
(2) if we don't change it, we also lost binary compatibility of
Sharyathi's use case.
Then, I would propse to change the rule of the len argument of
sched_getaffinity().
Old:
len should be bigger than NR_CPUS
New:
len should be bigger than maximum possible cpu id
This creates the following behavior:
(A) In the real 4096 cpus machine, the above test program still
return -EINVAL.
(B) NR_CPUS=4096 but the machine have less than 1024 cpus (almost
all machines in the world), the above can run successfully.
Fortunatelly, BIG SGI machine is mainly used for HPC use case. It means
they can rebuild their programs.
IOW we hope they are not annoyed by this issue ...
Reported-by: Sharyathi Nagesh <sharyath@in.ibm.com>
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Acked-by: Ulrich Drepper <drepper@redhat.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Jack Steiner <steiner@sgi.com>
Cc: Russ Anderson <rja@sgi.com>
Cc: Mike Travis <travis@sgi.com>
LKML-Reference: <20100312161316.9520.A69D9226@jp.fujitsu.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2010-03-12 14:15:36 +07:00
|
|
|
ret = retlen;
|
2008-11-24 23:05:11 +07:00
|
|
|
}
|
|
|
|
free_cpumask_var(mask);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:11 +07:00
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_yield - yield the current processor to other threads.
|
|
|
|
*
|
2007-07-09 23:51:59 +07:00
|
|
|
* This function yields the current CPU to other tasks. If there are no
|
|
|
|
* other threads running on this CPU then this function will return.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE0(sched_yield)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = this_rq_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:12 +07:00
|
|
|
schedstat_inc(rq, yld_count);
|
2007-10-15 22:00:08 +07:00
|
|
|
current->sched_class->yield_task(rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we are going to call schedule() anyway, there's
|
|
|
|
* no need to preempt or enable interrupts:
|
|
|
|
*/
|
|
|
|
__release(rq->lock);
|
2006-07-03 14:24:54 +07:00
|
|
|
spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
|
2009-12-04 02:55:53 +07:00
|
|
|
do_raw_spin_unlock(&rq->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
preempt_enable_no_resched();
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-10 19:57:57 +07:00
|
|
|
static inline int should_resched(void)
|
|
|
|
{
|
|
|
|
return need_resched() && !(preempt_count() & PREEMPT_ACTIVE);
|
|
|
|
}
|
|
|
|
|
2006-06-30 15:56:00 +07:00
|
|
|
static void __cond_resched(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-07-16 20:44:29 +07:00
|
|
|
add_preempt_count(PREEMPT_ACTIVE);
|
|
|
|
schedule();
|
|
|
|
sub_preempt_count(PREEMPT_ACTIVE);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:28 +07:00
|
|
|
int __sched _cond_resched(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-07-10 19:57:57 +07:00
|
|
|
if (should_resched()) {
|
2005-04-17 05:20:36 +07:00
|
|
|
__cond_resched();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-26 03:08:28 +07:00
|
|
|
EXPORT_SYMBOL(_cond_resched);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2009-07-16 20:44:29 +07:00
|
|
|
* __cond_resched_lock() - if a reschedule is pending, drop the given lock,
|
2005-04-17 05:20:36 +07:00
|
|
|
* call schedule, and on return reacquire the lock.
|
|
|
|
*
|
2007-12-05 21:46:09 +07:00
|
|
|
* This works OK both with and without CONFIG_PREEMPT. We do strange low-level
|
2005-04-17 05:20:36 +07:00
|
|
|
* operations here to prevent schedule() from being called twice (once via
|
|
|
|
* spin_unlock(), once by hand).
|
|
|
|
*/
|
2009-07-16 20:44:29 +07:00
|
|
|
int __cond_resched_lock(spinlock_t *lock)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-07-10 19:57:57 +07:00
|
|
|
int resched = should_resched();
|
2005-06-14 05:52:32 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
2009-07-21 00:16:29 +07:00
|
|
|
lockdep_assert_held(lock);
|
|
|
|
|
2008-01-30 19:31:20 +07:00
|
|
|
if (spin_needbreak(lock) || resched) {
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock(lock);
|
2009-07-10 19:57:57 +07:00
|
|
|
if (resched)
|
2008-01-30 19:31:20 +07:00
|
|
|
__cond_resched();
|
|
|
|
else
|
|
|
|
cpu_relax();
|
2005-06-14 05:52:32 +07:00
|
|
|
ret = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock(lock);
|
|
|
|
}
|
2005-06-14 05:52:32 +07:00
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-07-16 20:44:29 +07:00
|
|
|
EXPORT_SYMBOL(__cond_resched_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-07-16 20:44:29 +07:00
|
|
|
int __sched __cond_resched_softirq(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
BUG_ON(!in_softirq());
|
|
|
|
|
2009-07-10 19:57:57 +07:00
|
|
|
if (should_resched()) {
|
2007-05-24 03:58:18 +07:00
|
|
|
local_bh_enable();
|
2005-04-17 05:20:36 +07:00
|
|
|
__cond_resched();
|
|
|
|
local_bh_disable();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2009-07-16 20:44:29 +07:00
|
|
|
EXPORT_SYMBOL(__cond_resched_softirq);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* yield - yield the current processor to other threads.
|
|
|
|
*
|
2007-02-10 16:45:59 +07:00
|
|
|
* This is a shortcut for kernel-space yielding - it marks the
|
2005-04-17 05:20:36 +07:00
|
|
|
* thread runnable and calls sys_sched_yield().
|
|
|
|
*/
|
|
|
|
void __sched yield(void)
|
|
|
|
{
|
|
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
sys_sched_yield();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(yield);
|
|
|
|
|
|
|
|
/*
|
2007-12-05 21:46:09 +07:00
|
|
|
* This task is about to go to sleep on IO. Increment rq->nr_iowait so
|
2005-04-17 05:20:36 +07:00
|
|
|
* that process accounting knows that this is a task in IO wait state.
|
|
|
|
*/
|
|
|
|
void __sched io_schedule(void)
|
|
|
|
{
|
2009-06-29 12:44:57 +07:00
|
|
|
struct rq *rq = raw_rq();
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-14 14:24:37 +07:00
|
|
|
delayacct_blkio_start();
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_inc(&rq->nr_iowait);
|
2009-07-21 01:26:58 +07:00
|
|
|
current->in_iowait = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
schedule();
|
2009-07-21 01:26:58 +07:00
|
|
|
current->in_iowait = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_dec(&rq->nr_iowait);
|
2006-07-14 14:24:37 +07:00
|
|
|
delayacct_blkio_end();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(io_schedule);
|
|
|
|
|
|
|
|
long __sched io_schedule_timeout(long timeout)
|
|
|
|
{
|
2009-06-29 12:44:57 +07:00
|
|
|
struct rq *rq = raw_rq();
|
2005-04-17 05:20:36 +07:00
|
|
|
long ret;
|
|
|
|
|
2006-07-14 14:24:37 +07:00
|
|
|
delayacct_blkio_start();
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_inc(&rq->nr_iowait);
|
2009-07-21 01:26:58 +07:00
|
|
|
current->in_iowait = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = schedule_timeout(timeout);
|
2009-07-21 01:26:58 +07:00
|
|
|
current->in_iowait = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_dec(&rq->nr_iowait);
|
2006-07-14 14:24:37 +07:00
|
|
|
delayacct_blkio_end();
|
2005-04-17 05:20:36 +07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_get_priority_max - return maximum RT priority.
|
|
|
|
* @policy: scheduling class.
|
|
|
|
*
|
|
|
|
* this syscall returns the maximum rt_priority that can be used
|
|
|
|
* by a given scheduling class.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
switch (policy) {
|
|
|
|
case SCHED_FIFO:
|
|
|
|
case SCHED_RR:
|
|
|
|
ret = MAX_USER_RT_PRIO-1;
|
|
|
|
break;
|
|
|
|
case SCHED_NORMAL:
|
2006-01-15 04:20:41 +07:00
|
|
|
case SCHED_BATCH:
|
2007-07-09 23:51:59 +07:00
|
|
|
case SCHED_IDLE:
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_get_priority_min - return minimum RT priority.
|
|
|
|
* @policy: scheduling class.
|
|
|
|
*
|
|
|
|
* this syscall returns the minimum rt_priority that can be used
|
|
|
|
* by a given scheduling class.
|
|
|
|
*/
|
2009-01-14 20:14:08 +07:00
|
|
|
SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
switch (policy) {
|
|
|
|
case SCHED_FIFO:
|
|
|
|
case SCHED_RR:
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
case SCHED_NORMAL:
|
2006-01-15 04:20:41 +07:00
|
|
|
case SCHED_BATCH:
|
2007-07-09 23:51:59 +07:00
|
|
|
case SCHED_IDLE:
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sys_sched_rr_get_interval - return the default timeslice of a process.
|
|
|
|
* @pid: pid of the process.
|
|
|
|
* @interval: userspace pointer to the timeslice value.
|
|
|
|
*
|
|
|
|
* this syscall writes the default timeslice value of a given process
|
|
|
|
* into the user-space timespec buffer. A value of '0' means infinity.
|
|
|
|
*/
|
2009-01-14 20:14:10 +07:00
|
|
|
SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
|
2009-01-14 20:14:09 +07:00
|
|
|
struct timespec __user *, interval)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *p;
|
2007-10-15 22:00:13 +07:00
|
|
|
unsigned int time_slice;
|
2009-12-09 15:32:03 +07:00
|
|
|
unsigned long flags;
|
|
|
|
struct rq *rq;
|
2007-10-15 22:00:14 +07:00
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct timespec t;
|
|
|
|
|
|
|
|
if (pid < 0)
|
2007-10-15 22:00:14 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = -ESRCH;
|
2009-12-09 17:15:11 +07:00
|
|
|
rcu_read_lock();
|
2005-04-17 05:20:36 +07:00
|
|
|
p = find_process_by_pid(pid);
|
|
|
|
if (!p)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
retval = security_task_getscheduler(p);
|
|
|
|
if (retval)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2009-12-09 15:32:03 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
|
|
|
time_slice = p->sched_class->get_rr_interval(rq, p);
|
|
|
|
task_rq_unlock(rq, &flags);
|
2007-10-15 22:00:13 +07:00
|
|
|
|
2009-12-09 17:15:11 +07:00
|
|
|
rcu_read_unlock();
|
2007-10-15 22:00:13 +07:00
|
|
|
jiffies_to_timespec(time_slice, &t);
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = copy_to_user(interval, &t, sizeof(t)) ? -EFAULT : 0;
|
|
|
|
return retval;
|
2007-10-15 22:00:14 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
out_unlock:
|
2009-12-09 17:15:11 +07:00
|
|
|
rcu_read_unlock();
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-05-13 02:20:41 +07:00
|
|
|
static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;
|
2006-07-03 14:25:41 +07:00
|
|
|
|
2008-01-26 03:08:02 +07:00
|
|
|
void sched_show_task(struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long free = 0;
|
2006-07-03 14:25:41 +07:00
|
|
|
unsigned state;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
state = p->state ? __ffs(p->state) + 1 : 0;
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_INFO "%-13.13s %c", p->comm,
|
2006-07-10 18:43:52 +07:00
|
|
|
state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
|
2007-07-12 02:21:47 +07:00
|
|
|
#if BITS_PER_LONG == 32
|
2005-04-17 05:20:36 +07:00
|
|
|
if (state == TASK_RUNNING)
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT " running ");
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT " %08lx ", thread_saved_pc(p));
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
|
|
|
if (state == TASK_RUNNING)
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT " running task ");
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT " %016lx ", thread_saved_pc(p));
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_DEBUG_STACK_USAGE
|
2008-04-23 04:38:23 +07:00
|
|
|
free = stack_not_used(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free,
|
2009-05-04 15:38:05 +07:00
|
|
|
task_pid_nr(p), task_pid_nr(p->real_parent),
|
|
|
|
(unsigned long)task_thread_info(p)->flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-26 03:08:34 +07:00
|
|
|
show_stack(p, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-12-07 11:35:59 +07:00
|
|
|
void show_state_filter(unsigned long state_filter)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *g, *p;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-12 02:21:47 +07:00
|
|
|
#if BITS_PER_LONG == 32
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_INFO
|
|
|
|
" task PC stack pid father\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_INFO
|
|
|
|
" task PC stack pid father\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
read_lock(&tasklist_lock);
|
|
|
|
do_each_thread(g, p) {
|
|
|
|
/*
|
|
|
|
* reset the NMI-timeout, listing all files on a slow
|
|
|
|
* console might take alot of time:
|
|
|
|
*/
|
|
|
|
touch_nmi_watchdog();
|
2007-04-26 10:50:03 +07:00
|
|
|
if (!state_filter || (p->state & state_filter))
|
2008-01-26 03:08:02 +07:00
|
|
|
sched_show_task(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
} while_each_thread(g, p);
|
|
|
|
|
2007-05-08 14:28:05 +07:00
|
|
|
touch_all_softlockup_watchdogs();
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
sysrq_sched_debug_show();
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
read_unlock(&tasklist_lock);
|
2006-12-07 11:35:59 +07:00
|
|
|
/*
|
|
|
|
* Only show locks if all tasks are dumped:
|
|
|
|
*/
|
2009-11-25 20:23:41 +07:00
|
|
|
if (!state_filter)
|
2006-12-07 11:35:59 +07:00
|
|
|
debug_show_all_locks();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:58 +07:00
|
|
|
void __cpuinit init_idle_bootup_task(struct task_struct *idle)
|
|
|
|
{
|
2007-07-09 23:51:59 +07:00
|
|
|
idle->sched_class = &idle_sched_class;
|
2007-07-09 23:51:58 +07:00
|
|
|
}
|
|
|
|
|
2005-06-28 21:40:42 +07:00
|
|
|
/**
|
|
|
|
* init_idle - set up an idle thread for a given CPU
|
|
|
|
* @idle: task in question
|
|
|
|
* @cpu: cpu the idle task belongs to
|
|
|
|
*
|
|
|
|
* NOTE: this function does not set the idle thread's NEED_RESCHED
|
|
|
|
* flag, to make booting more robust.
|
|
|
|
*/
|
2006-10-03 15:14:04 +07:00
|
|
|
void __cpuinit init_idle(struct task_struct *idle, int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2008-11-13 02:05:50 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
__sched_fork(idle);
|
2009-12-17 00:04:35 +07:00
|
|
|
idle->state = TASK_RUNNING;
|
2007-07-09 23:51:59 +07:00
|
|
|
idle->se.exec_start = sched_clock();
|
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
cpumask_copy(&idle->cpus_allowed, cpumask_of(cpu));
|
2007-07-09 23:51:59 +07:00
|
|
|
__set_task_cpu(idle, cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rq->curr = rq->idle = idle;
|
2005-06-26 04:57:23 +07:00
|
|
|
#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
|
|
|
|
idle->oncpu = 1;
|
|
|
|
#endif
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Set the preempt count _outside_ the spinlocks! */
|
2008-05-11 10:58:02 +07:00
|
|
|
#if defined(CONFIG_PREEMPT)
|
|
|
|
task_thread_info(idle)->preempt_count = (idle->lock_depth >= 0);
|
|
|
|
#else
|
2005-11-14 07:06:55 +07:00
|
|
|
task_thread_info(idle)->preempt_count = 0;
|
2008-05-11 10:58:02 +07:00
|
|
|
#endif
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* The idle tasks have their own, simple scheduling class:
|
|
|
|
*/
|
|
|
|
idle->sched_class = &idle_sched_class;
|
2008-11-26 03:07:04 +07:00
|
|
|
ftrace_graph_init_task(idle);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In a system that switches off the HZ timer nohz_cpu_mask
|
|
|
|
* indicates which cpus entered this state. This is used
|
|
|
|
* in the rcu update to wait only for active cpus. For system
|
|
|
|
* which do not switch off the HZ timer nohz_cpu_mask should
|
2008-11-24 23:05:04 +07:00
|
|
|
* always be CPU_BITS_NONE.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-11-24 23:05:04 +07:00
|
|
|
cpumask_var_t nohz_cpu_mask;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-11-10 04:39:38 +07:00
|
|
|
/*
|
|
|
|
* Increase the granularity value when there are more CPUs,
|
|
|
|
* because with more CPUs the 'effective latency' as visible
|
|
|
|
* to users decreases. But the relationship is not linear,
|
|
|
|
* so pick a second-best guess by going with the log2 of the
|
|
|
|
* number of CPUs.
|
|
|
|
*
|
|
|
|
* This idea comes from the SD scheduler of Con Kolivas:
|
|
|
|
*/
|
2009-11-30 18:16:48 +07:00
|
|
|
static int get_update_sysctl_factor(void)
|
2007-11-10 04:39:38 +07:00
|
|
|
{
|
2009-12-10 15:25:53 +07:00
|
|
|
unsigned int cpus = min_t(int, num_online_cpus(), 8);
|
2009-11-30 18:16:47 +07:00
|
|
|
unsigned int factor;
|
|
|
|
|
|
|
|
switch (sysctl_sched_tunable_scaling) {
|
|
|
|
case SCHED_TUNABLESCALING_NONE:
|
|
|
|
factor = 1;
|
|
|
|
break;
|
|
|
|
case SCHED_TUNABLESCALING_LINEAR:
|
|
|
|
factor = cpus;
|
|
|
|
break;
|
|
|
|
case SCHED_TUNABLESCALING_LOG:
|
|
|
|
default:
|
|
|
|
factor = 1 + ilog2(cpus);
|
|
|
|
break;
|
|
|
|
}
|
2007-11-10 04:39:38 +07:00
|
|
|
|
2009-11-30 18:16:48 +07:00
|
|
|
return factor;
|
|
|
|
}
|
2007-11-10 04:39:38 +07:00
|
|
|
|
2009-11-30 18:16:48 +07:00
|
|
|
static void update_sysctl(void)
|
|
|
|
{
|
|
|
|
unsigned int factor = get_update_sysctl_factor();
|
2007-11-10 04:39:38 +07:00
|
|
|
|
2009-11-30 18:16:46 +07:00
|
|
|
#define SET_SYSCTL(name) \
|
|
|
|
(sysctl_##name = (factor) * normalized_sysctl_##name)
|
|
|
|
SET_SYSCTL(sched_min_granularity);
|
|
|
|
SET_SYSCTL(sched_latency);
|
|
|
|
SET_SYSCTL(sched_wakeup_granularity);
|
|
|
|
SET_SYSCTL(sched_shares_ratelimit);
|
|
|
|
#undef SET_SYSCTL
|
|
|
|
}
|
2008-08-04 13:54:26 +07:00
|
|
|
|
2009-11-30 18:16:46 +07:00
|
|
|
static inline void sched_init_granularity(void)
|
|
|
|
{
|
|
|
|
update_sysctl();
|
2007-11-10 04:39:38 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/*
|
|
|
|
* This is how migration works:
|
|
|
|
*
|
2010-05-06 23:49:21 +07:00
|
|
|
* 1) we invoke migration_cpu_stop() on the target CPU using
|
|
|
|
* stop_one_cpu().
|
|
|
|
* 2) stopper starts to run (implicitly forcing the migrated thread
|
|
|
|
* off the CPU)
|
|
|
|
* 3) it checks whether the migrated task is still in the wrong runqueue.
|
|
|
|
* 4) if it's in the wrong runqueue then the migration thread removes
|
2005-04-17 05:20:36 +07:00
|
|
|
* it and puts it into the right queue.
|
2010-05-06 23:49:21 +07:00
|
|
|
* 5) stopper completes and stop_one_cpu() returns and the migration
|
|
|
|
* is done.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change a given task's CPU affinity. Migrate the thread to a
|
|
|
|
* proper CPU and schedule it away if the CPU it's executing on
|
|
|
|
* is removed from the allowed bitmask.
|
|
|
|
*
|
|
|
|
* NOTE: the caller must have a valid reference to the task, the
|
2007-12-05 21:46:09 +07:00
|
|
|
* task must not exit() & deallocate itself prematurely. The
|
2005-04-17 05:20:36 +07:00
|
|
|
* call is not atomic; no spinlocks may be held.
|
|
|
|
*/
|
2008-11-24 23:05:14 +07:00
|
|
|
int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2010-05-06 23:49:21 +07:00
|
|
|
unsigned int dest_cpu;
|
2006-07-03 14:25:40 +07:00
|
|
|
int ret = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-03-26 03:05:16 +07:00
|
|
|
/*
|
|
|
|
* Serialize against TASK_WAKING so that ttwu() and wunt() can
|
|
|
|
* drop the rq->lock and still rely on ->cpus_allowed.
|
|
|
|
*/
|
|
|
|
again:
|
|
|
|
while (task_is_waking(p))
|
|
|
|
cpu_relax();
|
2005-04-17 05:20:36 +07:00
|
|
|
rq = task_rq_lock(p, &flags);
|
2010-03-26 03:05:16 +07:00
|
|
|
if (task_is_waking(p)) {
|
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
goto again;
|
|
|
|
}
|
2009-12-17 00:04:36 +07:00
|
|
|
|
2009-11-25 19:31:39 +07:00
|
|
|
if (!cpumask_intersects(new_mask, cpu_active_mask)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-06-06 02:57:11 +07:00
|
|
|
if (unlikely((p->flags & PF_THREAD_BOUND) && p != current &&
|
2008-11-24 23:05:14 +07:00
|
|
|
!cpumask_equal(&p->cpus_allowed, new_mask))) {
|
2008-06-06 02:57:11 +07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:07 +07:00
|
|
|
if (p->sched_class->set_cpus_allowed)
|
2008-03-27 04:23:49 +07:00
|
|
|
p->sched_class->set_cpus_allowed(p, new_mask);
|
2008-01-26 03:08:07 +07:00
|
|
|
else {
|
2008-11-24 23:05:14 +07:00
|
|
|
cpumask_copy(&p->cpus_allowed, new_mask);
|
|
|
|
p->rt.nr_cpus_allowed = cpumask_weight(new_mask);
|
2008-01-26 03:08:07 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Can the task run on the task's current CPU? If so, we're done */
|
2008-11-24 23:05:14 +07:00
|
|
|
if (cpumask_test_cpu(task_cpu(p), new_mask))
|
2005-04-17 05:20:36 +07:00
|
|
|
goto out;
|
|
|
|
|
2010-05-06 23:49:21 +07:00
|
|
|
dest_cpu = cpumask_any_and(cpu_active_mask, new_mask);
|
|
|
|
if (migrate_task(p, dest_cpu)) {
|
|
|
|
struct migration_arg arg = { p, dest_cpu };
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Need help from migration thread: drop lock and wait. */
|
|
|
|
task_rq_unlock(rq, &flags);
|
2010-05-06 23:49:21 +07:00
|
|
|
stop_one_cpu(cpu_of(rq), migration_cpu_stop, &arg);
|
2005-04-17 05:20:36 +07:00
|
|
|
tlb_migrate_finish(p->mm);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
task_rq_unlock(rq, &flags);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2008-03-27 04:23:49 +07:00
|
|
|
EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2007-12-05 21:46:09 +07:00
|
|
|
* Move (not current) task off this cpu, onto dest cpu. We're doing
|
2005-04-17 05:20:36 +07:00
|
|
|
* this because either it can't run here any more (set_cpus_allowed()
|
|
|
|
* away from this CPU, or CPU going down), or because we're
|
|
|
|
* attempting to rebalance this task on exec (sched_exec).
|
|
|
|
*
|
|
|
|
* So we race with normal scheduler movements, but that's OK, as long
|
|
|
|
* as the task is no longer on this CPU.
|
2006-06-27 16:54:32 +07:00
|
|
|
*
|
|
|
|
* Returns non-zero if task was successfully migrated.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-06-27 16:54:32 +07:00
|
|
|
static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq_dest, *rq_src;
|
2009-12-17 00:04:36 +07:00
|
|
|
int ret = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-15 18:43:49 +07:00
|
|
|
if (unlikely(!cpu_active(dest_cpu)))
|
2006-06-27 16:54:32 +07:00
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rq_src = cpu_rq(src_cpu);
|
|
|
|
rq_dest = cpu_rq(dest_cpu);
|
|
|
|
|
|
|
|
double_rq_lock(rq_src, rq_dest);
|
|
|
|
/* Already moved. */
|
|
|
|
if (task_cpu(p) != src_cpu)
|
2008-07-11 01:25:03 +07:00
|
|
|
goto done;
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Affinity changed (again). */
|
2008-11-24 23:05:14 +07:00
|
|
|
if (!cpumask_test_cpu(dest_cpu, &p->cpus_allowed))
|
2008-07-11 01:25:03 +07:00
|
|
|
goto fail;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-12-17 00:04:36 +07:00
|
|
|
/*
|
|
|
|
* If we're not on a rq, the next wake-up will ensure we're
|
|
|
|
* placed properly.
|
|
|
|
*/
|
|
|
|
if (p->se.on_rq) {
|
2007-08-09 16:16:49 +07:00
|
|
|
deactivate_task(rq_src, p, 0);
|
2009-12-17 00:04:36 +07:00
|
|
|
set_task_cpu(p, dest_cpu);
|
2007-07-09 23:51:59 +07:00
|
|
|
activate_task(rq_dest, p, 0);
|
2008-09-21 04:38:02 +07:00
|
|
|
check_preempt_curr(rq_dest, p, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-07-11 01:25:03 +07:00
|
|
|
done:
|
2006-06-27 16:54:32 +07:00
|
|
|
ret = 1;
|
2008-07-11 01:25:03 +07:00
|
|
|
fail:
|
2005-04-17 05:20:36 +07:00
|
|
|
double_rq_unlock(rq_src, rq_dest);
|
2006-06-27 16:54:32 +07:00
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-05-06 23:49:21 +07:00
|
|
|
* migration_cpu_stop - this will be executed by a highprio stopper thread
|
|
|
|
* and performs thread migration by bumping thread off CPU then
|
|
|
|
* 'pushing' onto another runqueue.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2010-05-06 23:49:21 +07:00
|
|
|
static int migration_cpu_stop(void *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-05-06 23:49:21 +07:00
|
|
|
struct migration_arg *arg = data;
|
2007-10-17 13:30:56 +07:00
|
|
|
|
2010-05-06 23:49:21 +07:00
|
|
|
/*
|
|
|
|
* The original target cpu might have gone down and we might
|
|
|
|
* be on another cpu but it doesn't matter.
|
|
|
|
*/
|
2007-10-17 13:30:56 +07:00
|
|
|
local_irq_disable();
|
2010-05-06 23:49:21 +07:00
|
|
|
__migrate_task(arg->task, raw_smp_processor_id(), arg->dest_cpu);
|
2007-10-17 13:30:56 +07:00
|
|
|
local_irq_enable();
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
2007-10-17 13:30:56 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
2006-12-10 17:20:11 +07:00
|
|
|
/*
|
2007-10-20 04:10:43 +07:00
|
|
|
* Figure out where task on dead CPU should go, use force if necessary.
|
2006-12-10 17:20:11 +07:00
|
|
|
*/
|
2010-03-15 16:10:23 +07:00
|
|
|
void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-03-15 16:10:10 +07:00
|
|
|
struct rq *rq = cpu_rq(dead_cpu);
|
|
|
|
int needs_cpu, uninitialized_var(dest_cpu);
|
|
|
|
unsigned long flags;
|
2008-11-24 23:05:11 +07:00
|
|
|
|
2010-03-15 16:10:10 +07:00
|
|
|
local_irq_save(flags);
|
2008-11-24 23:05:11 +07:00
|
|
|
|
2010-03-15 16:10:10 +07:00
|
|
|
raw_spin_lock(&rq->lock);
|
|
|
|
needs_cpu = (task_cpu(p) == dead_cpu) && (p->state != TASK_WAKING);
|
|
|
|
if (needs_cpu)
|
|
|
|
dest_cpu = select_fallback_rq(dead_cpu, p);
|
|
|
|
raw_spin_unlock(&rq->lock);
|
2010-03-15 16:10:14 +07:00
|
|
|
/*
|
|
|
|
* It can only fail if we race with set_cpus_allowed(),
|
|
|
|
* in the racer should migrate the task anyway.
|
|
|
|
*/
|
2010-03-15 16:10:10 +07:00
|
|
|
if (needs_cpu)
|
2010-03-15 16:10:14 +07:00
|
|
|
__migrate_task(p, dead_cpu, dest_cpu);
|
2010-03-15 16:10:10 +07:00
|
|
|
local_irq_restore(flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* While a dead CPU has no uninterruptible tasks queued at this point,
|
|
|
|
* it might still have a nonzero ->nr_uninterruptible counter, because
|
|
|
|
* for performance reasons the counter is not stricly tracking tasks to
|
|
|
|
* their home CPUs. So we just add the counter to another CPU's counter,
|
|
|
|
* to keep the global sum constant after CPU-down:
|
|
|
|
*/
|
2006-07-03 14:25:42 +07:00
|
|
|
static void migrate_nr_uninterruptible(struct rq *rq_src)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2009-11-25 19:31:39 +07:00
|
|
|
struct rq *rq_dest = cpu_rq(cpumask_any(cpu_active_mask));
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
double_rq_lock(rq_src, rq_dest);
|
|
|
|
rq_dest->nr_uninterruptible += rq_src->nr_uninterruptible;
|
|
|
|
rq_src->nr_uninterruptible = 0;
|
|
|
|
double_rq_unlock(rq_src, rq_dest);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Run through task list and migrate tasks from the dead cpu. */
|
|
|
|
static void migrate_live_tasks(int src_cpu)
|
|
|
|
{
|
2006-07-03 14:25:40 +07:00
|
|
|
struct task_struct *p, *t;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-17 13:30:56 +07:00
|
|
|
read_lock(&tasklist_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
do_each_thread(t, p) {
|
|
|
|
if (p == current)
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
if (task_cpu(p) == src_cpu)
|
|
|
|
move_task_off_dead_cpu(src_cpu, p);
|
|
|
|
} while_each_thread(t, p);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-17 13:30:56 +07:00
|
|
|
read_unlock(&tasklist_lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* Schedules idle task to be the next runnable task on current CPU.
|
2007-11-16 02:57:40 +07:00
|
|
|
* It does so by boosting its priority to highest possible.
|
|
|
|
* Used by CPU offline code.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
void sched_idle_next(void)
|
|
|
|
{
|
2006-07-03 14:25:40 +07:00
|
|
|
int this_cpu = smp_processor_id();
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = cpu_rq(this_cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
struct task_struct *p = rq->idle;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* cpu has to be offline */
|
2006-07-03 14:25:40 +07:00
|
|
|
BUG_ON(cpu_online(this_cpu));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
/*
|
|
|
|
* Strictly not necessary since rest of the CPUs are stopped by now
|
|
|
|
* and interrupts disabled on the current cpu.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
__setscheduler(rq, p, SCHED_FIFO, MAX_RT_PRIO-1);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2007-11-16 02:57:40 +07:00
|
|
|
activate_task(rq, p, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
/*
|
|
|
|
* Ensures that the idle task is using init_mm right before its cpu goes
|
2005-04-17 05:20:36 +07:00
|
|
|
* offline.
|
|
|
|
*/
|
|
|
|
void idle_task_exit(void)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = current->active_mm;
|
|
|
|
|
|
|
|
BUG_ON(cpu_online(smp_processor_id()));
|
|
|
|
|
|
|
|
if (mm != &init_mm)
|
|
|
|
switch_mm(mm, &init_mm, current);
|
|
|
|
mmdrop(mm);
|
|
|
|
}
|
|
|
|
|
2006-12-10 17:20:11 +07:00
|
|
|
/* called under rq->lock with disabled interrupts */
|
2006-07-03 14:25:41 +07:00
|
|
|
static void migrate_dead(unsigned int dead_cpu, struct task_struct *p)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = cpu_rq(dead_cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Must be exiting, otherwise would be on tasklist. */
|
2007-10-19 13:40:38 +07:00
|
|
|
BUG_ON(!p->exit_state);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Cannot have done final schedule yet: would have vanished. */
|
2006-09-29 16:01:11 +07:00
|
|
|
BUG_ON(p->state == TASK_DEAD);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
get_task_struct(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Drop lock around migration; if someone else moves it,
|
2007-12-05 21:46:09 +07:00
|
|
|
* that's OK. No task can be added to this CPU, so iteration is
|
2005-04-17 05:20:36 +07:00
|
|
|
* fine.
|
|
|
|
*/
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
2006-07-03 14:25:40 +07:00
|
|
|
move_task_off_dead_cpu(dead_cpu, p);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irq(&rq->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
put_task_struct(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* release_task() removes task from tasklist, so we won't find dead tasks. */
|
|
|
|
static void migrate_dead_tasks(unsigned int dead_cpu)
|
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = cpu_rq(dead_cpu);
|
2007-07-09 23:51:59 +07:00
|
|
|
struct task_struct *next;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
for ( ; ; ) {
|
|
|
|
if (!rq->nr_running)
|
|
|
|
break;
|
2009-03-02 12:55:26 +07:00
|
|
|
next = pick_next_task(rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
if (!next)
|
|
|
|
break;
|
2008-06-29 05:16:56 +07:00
|
|
|
next->sched_class->put_prev_task(rq, next);
|
2007-07-09 23:51:59 +07:00
|
|
|
migrate_dead(dead_cpu, next);
|
2007-07-26 18:40:43 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
2009-04-11 15:43:41 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* remove the tasks which were accounted by rq from calc_load_tasks.
|
|
|
|
*/
|
|
|
|
static void calc_global_load_remove(struct rq *rq)
|
|
|
|
{
|
|
|
|
atomic_long_sub(rq->calc_load_active, &calc_load_tasks);
|
2009-07-17 19:15:46 +07:00
|
|
|
rq->calc_load_active = 0;
|
2009-04-11 15:43:41 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif /* CONFIG_HOTPLUG_CPU */
|
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
#if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)
|
|
|
|
|
|
|
|
static struct ctl_table sd_ctl_dir[] = {
|
2007-08-09 16:16:46 +07:00
|
|
|
{
|
|
|
|
.procname = "sched_domain",
|
2007-08-23 20:18:02 +07:00
|
|
|
.mode = 0555,
|
2007-08-09 16:16:46 +07:00
|
|
|
},
|
2009-11-06 06:38:40 +07:00
|
|
|
{}
|
2007-07-26 18:40:43 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct ctl_table sd_ctl_root[] = {
|
2007-08-09 16:16:46 +07:00
|
|
|
{
|
|
|
|
.procname = "kernel",
|
2007-08-23 20:18:02 +07:00
|
|
|
.mode = 0555,
|
2007-08-09 16:16:46 +07:00
|
|
|
.child = sd_ctl_dir,
|
|
|
|
},
|
2009-11-06 06:38:40 +07:00
|
|
|
{}
|
2007-07-26 18:40:43 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct ctl_table *sd_alloc_ctl_entry(int n)
|
|
|
|
{
|
|
|
|
struct ctl_table *entry =
|
2007-10-15 22:00:19 +07:00
|
|
|
kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);
|
2007-07-26 18:40:43 +07:00
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:19 +07:00
|
|
|
static void sd_free_ctl_entry(struct ctl_table **tablep)
|
|
|
|
{
|
2007-10-17 21:55:11 +07:00
|
|
|
struct ctl_table *entry;
|
2007-10-15 22:00:19 +07:00
|
|
|
|
2007-10-17 21:55:11 +07:00
|
|
|
/*
|
|
|
|
* In the intermediate directories, both the child directory and
|
|
|
|
* procname are dynamically allocated and could fail but the mode
|
2007-12-05 21:46:09 +07:00
|
|
|
* will always be set. In the lowest directory the names are
|
2007-10-17 21:55:11 +07:00
|
|
|
* static strings and all have proc handlers.
|
|
|
|
*/
|
|
|
|
for (entry = *tablep; entry->mode; entry++) {
|
2007-10-15 22:00:19 +07:00
|
|
|
if (entry->child)
|
|
|
|
sd_free_ctl_entry(&entry->child);
|
2007-10-17 21:55:11 +07:00
|
|
|
if (entry->proc_handler == NULL)
|
|
|
|
kfree(entry->procname);
|
|
|
|
}
|
2007-10-15 22:00:19 +07:00
|
|
|
|
|
|
|
kfree(*tablep);
|
|
|
|
*tablep = NULL;
|
|
|
|
}
|
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
static void
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(struct ctl_table *entry,
|
2007-07-26 18:40:43 +07:00
|
|
|
const char *procname, void *data, int maxlen,
|
|
|
|
mode_t mode, proc_handler *proc_handler)
|
|
|
|
{
|
|
|
|
entry->procname = procname;
|
|
|
|
entry->data = data;
|
|
|
|
entry->maxlen = maxlen;
|
|
|
|
entry->mode = mode;
|
|
|
|
entry->proc_handler = proc_handler;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ctl_table *
|
|
|
|
sd_alloc_ctl_domain_table(struct sched_domain *sd)
|
|
|
|
{
|
2008-10-09 16:35:51 +07:00
|
|
|
struct ctl_table *table = sd_alloc_ctl_entry(13);
|
2007-07-26 18:40:43 +07:00
|
|
|
|
2007-10-15 22:00:19 +07:00
|
|
|
if (table == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[0], "min_interval", &sd->min_interval,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(long), 0644, proc_doulongvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[1], "max_interval", &sd->max_interval,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(long), 0644, proc_doulongvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[2], "busy_idx", &sd->busy_idx,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[3], "idle_idx", &sd->idle_idx,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[4], "newidle_idx", &sd->newidle_idx,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[5], "wake_idx", &sd->wake_idx,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[6], "forkexec_idx", &sd->forkexec_idx,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[7], "busy_factor", &sd->busy_factor,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-08-09 16:16:46 +07:00
|
|
|
set_table_entry(&table[8], "imbalance_pct", &sd->imbalance_pct,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-10-15 22:00:14 +07:00
|
|
|
set_table_entry(&table[9], "cache_nice_tries",
|
2007-07-26 18:40:43 +07:00
|
|
|
&sd->cache_nice_tries,
|
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2007-10-15 22:00:14 +07:00
|
|
|
set_table_entry(&table[10], "flags", &sd->flags,
|
2007-07-26 18:40:43 +07:00
|
|
|
sizeof(int), 0644, proc_dointvec_minmax);
|
2008-10-09 16:35:51 +07:00
|
|
|
set_table_entry(&table[11], "name", sd->name,
|
|
|
|
CORENAME_MAX_SIZE, 0444, proc_dostring);
|
|
|
|
/* &table[12] is terminator */
|
2007-07-26 18:40:43 +07:00
|
|
|
|
|
|
|
return table;
|
|
|
|
}
|
|
|
|
|
2007-11-28 21:52:56 +07:00
|
|
|
static ctl_table *sd_alloc_ctl_cpu_table(int cpu)
|
2007-07-26 18:40:43 +07:00
|
|
|
{
|
|
|
|
struct ctl_table *entry, *table;
|
|
|
|
struct sched_domain *sd;
|
|
|
|
int domain_num = 0, i;
|
|
|
|
char buf[32];
|
|
|
|
|
|
|
|
for_each_domain(cpu, sd)
|
|
|
|
domain_num++;
|
|
|
|
entry = table = sd_alloc_ctl_entry(domain_num + 1);
|
2007-10-15 22:00:19 +07:00
|
|
|
if (table == NULL)
|
|
|
|
return NULL;
|
2007-07-26 18:40:43 +07:00
|
|
|
|
|
|
|
i = 0;
|
|
|
|
for_each_domain(cpu, sd) {
|
|
|
|
snprintf(buf, 32, "domain%d", i);
|
|
|
|
entry->procname = kstrdup(buf, GFP_KERNEL);
|
2007-08-23 20:18:02 +07:00
|
|
|
entry->mode = 0555;
|
2007-07-26 18:40:43 +07:00
|
|
|
entry->child = sd_alloc_ctl_domain_table(sd);
|
|
|
|
entry++;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return table;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ctl_table_header *sd_sysctl_header;
|
2007-10-15 22:00:19 +07:00
|
|
|
static void register_sched_domain_sysctl(void)
|
2007-07-26 18:40:43 +07:00
|
|
|
{
|
2009-11-25 19:31:39 +07:00
|
|
|
int i, cpu_num = num_possible_cpus();
|
2007-07-26 18:40:43 +07:00
|
|
|
struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);
|
|
|
|
char buf[32];
|
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
WARN_ON(sd_ctl_dir[0].child);
|
|
|
|
sd_ctl_dir[0].child = entry;
|
|
|
|
|
2007-10-15 22:00:19 +07:00
|
|
|
if (entry == NULL)
|
|
|
|
return;
|
|
|
|
|
2009-11-25 19:31:39 +07:00
|
|
|
for_each_possible_cpu(i) {
|
2007-07-26 18:40:43 +07:00
|
|
|
snprintf(buf, 32, "cpu%d", i);
|
|
|
|
entry->procname = kstrdup(buf, GFP_KERNEL);
|
2007-08-23 20:18:02 +07:00
|
|
|
entry->mode = 0555;
|
2007-07-26 18:40:43 +07:00
|
|
|
entry->child = sd_alloc_ctl_cpu_table(i);
|
2007-10-15 22:00:19 +07:00
|
|
|
entry++;
|
2007-07-26 18:40:43 +07:00
|
|
|
}
|
2007-10-24 23:23:48 +07:00
|
|
|
|
|
|
|
WARN_ON(sd_sysctl_header);
|
2007-07-26 18:40:43 +07:00
|
|
|
sd_sysctl_header = register_sysctl_table(sd_ctl_root);
|
|
|
|
}
|
2007-10-15 22:00:19 +07:00
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
/* may be called multiple times per register */
|
2007-10-15 22:00:19 +07:00
|
|
|
static void unregister_sched_domain_sysctl(void)
|
|
|
|
{
|
2007-10-24 23:23:48 +07:00
|
|
|
if (sd_sysctl_header)
|
|
|
|
unregister_sysctl_table(sd_sysctl_header);
|
2007-10-15 22:00:19 +07:00
|
|
|
sd_sysctl_header = NULL;
|
2007-10-24 23:23:48 +07:00
|
|
|
if (sd_ctl_dir[0].child)
|
|
|
|
sd_free_ctl_entry(&sd_ctl_dir[0].child);
|
2007-10-15 22:00:19 +07:00
|
|
|
}
|
2007-07-26 18:40:43 +07:00
|
|
|
#else
|
2007-10-15 22:00:19 +07:00
|
|
|
static void register_sched_domain_sysctl(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
static void unregister_sched_domain_sysctl(void)
|
2007-07-26 18:40:43 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-06-05 02:04:05 +07:00
|
|
|
static void set_rq_online(struct rq *rq)
|
|
|
|
{
|
|
|
|
if (!rq->online) {
|
|
|
|
const struct sched_class *class;
|
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
cpumask_set_cpu(rq->cpu, rq->rd->online);
|
2008-06-05 02:04:05 +07:00
|
|
|
rq->online = 1;
|
|
|
|
|
|
|
|
for_each_class(class) {
|
|
|
|
if (class->rq_online)
|
|
|
|
class->rq_online(rq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_rq_offline(struct rq *rq)
|
|
|
|
{
|
|
|
|
if (rq->online) {
|
|
|
|
const struct sched_class *class;
|
|
|
|
|
|
|
|
for_each_class(class) {
|
|
|
|
if (class->rq_offline)
|
|
|
|
class->rq_offline(rq);
|
|
|
|
}
|
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
cpumask_clear_cpu(rq->cpu, rq->rd->online);
|
2008-06-05 02:04:05 +07:00
|
|
|
rq->online = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* migration_call - callback that gets triggered when a CPU is added.
|
|
|
|
* Here we can start up the necessary migration thread for the new CPU.
|
|
|
|
*/
|
2006-07-03 14:25:40 +07:00
|
|
|
static int __cpuinit
|
|
|
|
migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:40 +07:00
|
|
|
int cpu = (long)hcpu;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
2010-05-06 23:49:21 +07:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
switch (action) {
|
2007-05-09 16:34:04 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
case CPU_UP_PREPARE:
|
2007-05-09 16:35:10 +07:00
|
|
|
case CPU_UP_PREPARE_FROZEN:
|
2009-07-17 19:15:46 +07:00
|
|
|
rq->calc_load_update = calc_load_update;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
case CPU_ONLINE:
|
2007-05-09 16:35:10 +07:00
|
|
|
case CPU_ONLINE_FROZEN:
|
2008-03-11 03:52:41 +07:00
|
|
|
/* Update our root-domain */
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2008-03-11 03:52:41 +07:00
|
|
|
if (rq->rd) {
|
2008-11-24 23:05:05 +07:00
|
|
|
BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
|
2008-06-05 02:04:05 +07:00
|
|
|
|
|
|
|
set_rq_online(rq);
|
2008-03-11 03:52:41 +07:00
|
|
|
}
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
case CPU_DEAD:
|
2007-05-09 16:35:10 +07:00
|
|
|
case CPU_DEAD_FROZEN:
|
2005-04-17 05:20:36 +07:00
|
|
|
migrate_live_tasks(cpu);
|
|
|
|
/* Idle task back to normal (off runqueue, low prio) */
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irq(&rq->lock);
|
2007-08-09 16:16:49 +07:00
|
|
|
deactivate_task(rq, rq->idle, 0);
|
2007-07-09 23:51:59 +07:00
|
|
|
__setscheduler(rq, rq->idle, SCHED_NORMAL, 0);
|
|
|
|
rq->idle->sched_class = &idle_sched_class;
|
2005-04-17 05:20:36 +07:00
|
|
|
migrate_dead_tasks(cpu);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
migrate_nr_uninterruptible(rq);
|
|
|
|
BUG_ON(rq->nr_running != 0);
|
2009-04-11 15:43:41 +07:00
|
|
|
calc_global_load_remove(rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2008-01-26 03:08:18 +07:00
|
|
|
|
2008-03-11 04:59:11 +07:00
|
|
|
case CPU_DYING:
|
|
|
|
case CPU_DYING_FROZEN:
|
2008-01-26 03:08:18 +07:00
|
|
|
/* Update our root-domain */
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2008-01-26 03:08:18 +07:00
|
|
|
if (rq->rd) {
|
2008-11-24 23:05:05 +07:00
|
|
|
BUG_ON(!cpumask_test_cpu(cpu, rq->rd->span));
|
2008-06-05 02:04:05 +07:00
|
|
|
set_rq_offline(rq);
|
2008-01-26 03:08:18 +07:00
|
|
|
}
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2008-01-26 03:08:18 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
2009-06-02 18:05:16 +07:00
|
|
|
/*
|
|
|
|
* Register at high priority so that task migration (migrate_all_tasks)
|
|
|
|
* happens before everything else. This has to be lower priority than
|
perf: Do the big rename: Performance Counters -> Performance Events
Bye-bye Performance Counters, welcome Performance Events!
In the past few months the perfcounters subsystem has grown out its
initial role of counting hardware events, and has become (and is
becoming) a much broader generic event enumeration, reporting, logging,
monitoring, analysis facility.
Naming its core object 'perf_counter' and naming the subsystem
'perfcounters' has become more and more of a misnomer. With pending
code like hw-breakpoints support the 'counter' name is less and
less appropriate.
All in one, we've decided to rename the subsystem to 'performance
events' and to propagate this rename through all fields, variables
and API names. (in an ABI compatible fashion)
The word 'event' is also a bit shorter than 'counter' - which makes
it slightly more convenient to write/handle as well.
Thanks goes to Stephane Eranian who first observed this misnomer and
suggested a rename.
User-space tooling and ABI compatibility is not affected - this patch
should be function-invariant. (Also, defconfigs were not touched to
keep the size down.)
This patch has been generated via the following script:
FILES=$(find * -type f | grep -vE 'oprofile|[^K]config')
sed -i \
-e 's/PERF_EVENT_/PERF_RECORD_/g' \
-e 's/PERF_COUNTER/PERF_EVENT/g' \
-e 's/perf_counter/perf_event/g' \
-e 's/nb_counters/nb_events/g' \
-e 's/swcounter/swevent/g' \
-e 's/tpcounter_event/tp_event/g' \
$FILES
for N in $(find . -name perf_counter.[ch]); do
M=$(echo $N | sed 's/perf_counter/perf_event/g')
mv $N $M
done
FILES=$(find . -name perf_event.*)
sed -i \
-e 's/COUNTER_MASK/REG_MASK/g' \
-e 's/COUNTER/EVENT/g' \
-e 's/\<event\>/event_id/g' \
-e 's/counter/event/g' \
-e 's/Counter/Event/g' \
$FILES
... to keep it as correct as possible. This script can also be
used by anyone who has pending perfcounters patches - it converts
a Linux kernel tree over to the new naming. We tried to time this
change to the point in time where the amount of pending patches
is the smallest: the end of the merge window.
Namespace clashes were fixed up in a preparatory patch - and some
stylistic fallout will be fixed up in a subsequent patch.
( NOTE: 'counters' are still the proper terminology when we deal
with hardware registers - and these sed scripts are a bit
over-eager in renaming them. I've undone some of that, but
in case there's something left where 'counter' would be
better than 'event' we can undo that on an individual basis
instead of touching an otherwise nicely automated patch. )
Suggested-by: Stephane Eranian <eranian@google.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Paul Mackerras <paulus@samba.org>
Reviewed-by: Arjan van de Ven <arjan@linux.intel.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: <linux-arch@vger.kernel.org>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-21 17:02:48 +07:00
|
|
|
* the notifier in the perf_event subsystem, though.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-06-27 16:54:10 +07:00
|
|
|
static struct notifier_block __cpuinitdata migration_notifier = {
|
2005-04-17 05:20:36 +07:00
|
|
|
.notifier_call = migration_call,
|
|
|
|
.priority = 10
|
|
|
|
};
|
|
|
|
|
2008-07-26 09:45:11 +07:00
|
|
|
static int __init migration_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
void *cpu = (void *)(long)smp_processor_id();
|
2006-09-29 16:00:22 +07:00
|
|
|
int err;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
|
|
|
/* Start one for the boot CPU: */
|
2006-09-29 16:00:22 +07:00
|
|
|
err = migration_call(&migration_notifier, CPU_UP_PREPARE, cpu);
|
|
|
|
BUG_ON(err == NOTIFY_BAD);
|
2005-04-17 05:20:36 +07:00
|
|
|
migration_call(&migration_notifier, CPU_ONLINE, cpu);
|
|
|
|
register_cpu_notifier(&migration_notifier);
|
2008-07-26 09:45:11 +07:00
|
|
|
|
2009-07-21 14:54:05 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-07-26 09:45:11 +07:00
|
|
|
early_initcall(migration_init);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2007-05-07 04:48:58 +07:00
|
|
|
|
2007-10-15 22:00:13 +07:00
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
2007-10-24 23:23:48 +07:00
|
|
|
|
2009-11-18 07:22:15 +07:00
|
|
|
static __read_mostly int sched_domain_debug_enabled;
|
|
|
|
|
|
|
|
static int __init sched_domain_debug_setup(char *str)
|
|
|
|
{
|
|
|
|
sched_domain_debug_enabled = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("sched_debug", sched_domain_debug_setup);
|
|
|
|
|
2008-04-05 08:11:11 +07:00
|
|
|
static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
|
2008-11-24 23:05:14 +07:00
|
|
|
struct cpumask *groupmask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-24 23:23:48 +07:00
|
|
|
struct sched_group *group = sd->groups;
|
2008-04-05 08:11:04 +07:00
|
|
|
char str[256];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-12-13 18:25:51 +07:00
|
|
|
cpulist_scnprintf(str, sizeof(str), sched_domain_span(sd));
|
2008-11-24 23:05:14 +07:00
|
|
|
cpumask_clear(groupmask);
|
2007-10-24 23:23:48 +07:00
|
|
|
|
|
|
|
printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
|
|
|
|
|
|
|
|
if (!(sd->flags & SD_LOAD_BALANCE)) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk("does not load-balance\n");
|
2007-10-24 23:23:48 +07:00
|
|
|
if (sd->parent)
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
|
|
|
|
" has parent");
|
2007-10-24 23:23:48 +07:00
|
|
|
return -1;
|
2005-06-26 04:57:24 +07:00
|
|
|
}
|
|
|
|
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT "span %s level %s\n", str, sd->name);
|
2007-10-24 23:23:48 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (!cpumask_test_cpu(cpu, sched_domain_span(sd))) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR "ERROR: domain->span does not contain "
|
|
|
|
"CPU%d\n", cpu);
|
2007-10-24 23:23:48 +07:00
|
|
|
}
|
2008-11-24 23:05:04 +07:00
|
|
|
if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR "ERROR: domain->groups does not contain"
|
|
|
|
" CPU%d\n", cpu);
|
2007-10-24 23:23:48 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
printk(KERN_DEBUG "%*s groups:", level + 1, "");
|
2005-04-17 05:20:36 +07:00
|
|
|
do {
|
2007-10-24 23:23:48 +07:00
|
|
|
if (!group) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk("\n");
|
|
|
|
printk(KERN_ERR "ERROR: group is NULL\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-09-01 15:34:39 +07:00
|
|
|
if (!group->cpu_power) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
printk(KERN_ERR "ERROR: domain->cpu_power not "
|
|
|
|
"set\n");
|
2007-10-24 23:23:48 +07:00
|
|
|
break;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (!cpumask_weight(sched_group_cpus(group))) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
printk(KERN_ERR "ERROR: empty group\n");
|
2007-10-24 23:23:48 +07:00
|
|
|
break;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (cpumask_intersects(groupmask, sched_group_cpus(group))) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
printk(KERN_ERR "ERROR: repeated CPUs\n");
|
2007-10-24 23:23:48 +07:00
|
|
|
break;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
cpumask_or(groupmask, groupmask, sched_group_cpus(group));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-12-13 18:25:51 +07:00
|
|
|
cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
|
2009-04-14 10:39:36 +07:00
|
|
|
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT " %s", str);
|
2009-09-01 15:34:39 +07:00
|
|
|
if (group->cpu_power != SCHED_LOAD_SCALE) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT " (cpu_power = %d)",
|
|
|
|
group->cpu_power);
|
2009-04-14 10:39:36 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
group = group->next;
|
|
|
|
} while (group != sd->groups);
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_CONT "\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (!cpumask_equal(sched_domain_span(sd), groupmask))
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR "ERROR: groups don't span domain->span\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (sd->parent &&
|
|
|
|
!cpumask_subset(groupmask, sched_domain_span(sd->parent)))
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR "ERROR: parent span is not a superset "
|
|
|
|
"of domain->span\n");
|
2007-10-24 23:23:48 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
static void sched_domain_debug(struct sched_domain *sd, int cpu)
|
|
|
|
{
|
2008-11-24 23:05:12 +07:00
|
|
|
cpumask_var_t groupmask;
|
2007-10-24 23:23:48 +07:00
|
|
|
int level = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-11-18 07:22:15 +07:00
|
|
|
if (!sched_domain_debug_enabled)
|
|
|
|
return;
|
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
if (!sd) {
|
|
|
|
printk(KERN_DEBUG "CPU%d attaching NULL sched-domain.\n", cpu);
|
|
|
|
return;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
|
|
|
|
|
2008-11-24 23:05:12 +07:00
|
|
|
if (!alloc_cpumask_var(&groupmask, GFP_KERNEL)) {
|
2008-04-05 08:11:11 +07:00
|
|
|
printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
for (;;) {
|
2008-04-05 08:11:11 +07:00
|
|
|
if (sched_domain_debug_one(sd, cpu, level, groupmask))
|
2007-10-24 23:23:48 +07:00
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
level++;
|
|
|
|
sd = sd->parent;
|
2006-12-10 17:20:38 +07:00
|
|
|
if (!sd)
|
2007-10-24 23:23:48 +07:00
|
|
|
break;
|
|
|
|
}
|
2008-11-24 23:05:12 +07:00
|
|
|
free_cpumask_var(groupmask);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFIG_SCHED_DEBUG */
|
2006-07-03 14:25:40 +07:00
|
|
|
# define sched_domain_debug(sd, cpu) do { } while (0)
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_SCHED_DEBUG */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-26 04:57:33 +07:00
|
|
|
static int sd_degenerate(struct sched_domain *sd)
|
2005-06-26 04:57:25 +07:00
|
|
|
{
|
2008-11-24 23:05:04 +07:00
|
|
|
if (cpumask_weight(sched_domain_span(sd)) == 1)
|
2005-06-26 04:57:25 +07:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Following flags need at least 2 groups */
|
|
|
|
if (sd->flags & (SD_LOAD_BALANCE |
|
|
|
|
SD_BALANCE_NEWIDLE |
|
|
|
|
SD_BALANCE_FORK |
|
2006-10-03 15:14:09 +07:00
|
|
|
SD_BALANCE_EXEC |
|
|
|
|
SD_SHARE_CPUPOWER |
|
|
|
|
SD_SHARE_PKG_RESOURCES)) {
|
2005-06-26 04:57:25 +07:00
|
|
|
if (sd->groups != sd->groups->next)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Following flags don't use groups */
|
sched: Merge select_task_rq_fair() and sched_balance_self()
The problem with wake_idle() is that is doesn't respect things like
cpu_power, which means it doesn't deal well with SMT nor the recent
RT interaction.
To cure this, it needs to do what sched_balance_self() does, which
leads to the possibility of merging select_task_rq_fair() and
sched_balance_self().
Modify sched_balance_self() to:
- update_shares() when walking up the domain tree,
(it only called it for the top domain, but it should
have done this anyway), which allows us to remove
this ugly bit from try_to_wake_up().
- do wake_affine() on the smallest domain that contains
both this (the waking) and the prev (the wakee) cpu for
WAKE invocations.
Then use the top-down balance steps it had to replace wake_idle().
This leads to the dissapearance of SD_WAKE_BALANCE and
SD_WAKE_IDLE_FAR, with SD_WAKE_IDLE replaced with SD_BALANCE_WAKE.
SD_WAKE_AFFINE needs SD_BALANCE_WAKE to be effective.
Touch all topology bits to replace the old with new SD flags --
platforms might need re-tuning, enabling SD_BALANCE_WAKE
conditionally on a NUMA distance seems like a good additional
feature, magny-core and small nehalem systems would want this
enabled, systems with slow interconnects would not.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-10 18:50:02 +07:00
|
|
|
if (sd->flags & (SD_WAKE_AFFINE))
|
2005-06-26 04:57:25 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
static int
|
|
|
|
sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
|
2005-06-26 04:57:25 +07:00
|
|
|
{
|
|
|
|
unsigned long cflags = sd->flags, pflags = parent->flags;
|
|
|
|
|
|
|
|
if (sd_degenerate(parent))
|
|
|
|
return 1;
|
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (!cpumask_equal(sched_domain_span(sd), sched_domain_span(parent)))
|
2005-06-26 04:57:25 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Flags needing groups don't count if only 1 group in parent */
|
|
|
|
if (parent->groups == parent->groups->next) {
|
|
|
|
pflags &= ~(SD_LOAD_BALANCE |
|
|
|
|
SD_BALANCE_NEWIDLE |
|
|
|
|
SD_BALANCE_FORK |
|
2006-10-03 15:14:09 +07:00
|
|
|
SD_BALANCE_EXEC |
|
|
|
|
SD_SHARE_CPUPOWER |
|
|
|
|
SD_SHARE_PKG_RESOURCES);
|
2008-12-08 09:47:37 +07:00
|
|
|
if (nr_node_ids == 1)
|
|
|
|
pflags &= ~SD_SERIALIZE;
|
2005-06-26 04:57:25 +07:00
|
|
|
}
|
|
|
|
if (~cflags & pflags)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
static void free_rootdomain(struct root_domain *rd)
|
|
|
|
{
|
2009-11-16 16:28:09 +07:00
|
|
|
synchronize_sched();
|
|
|
|
|
2008-11-24 23:05:13 +07:00
|
|
|
cpupri_cleanup(&rd->cpupri);
|
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
free_cpumask_var(rd->rto_mask);
|
|
|
|
free_cpumask_var(rd->online);
|
|
|
|
free_cpumask_var(rd->span);
|
|
|
|
kfree(rd);
|
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:18 +07:00
|
|
|
static void rq_attach_root(struct rq *rq, struct root_domain *rd)
|
|
|
|
{
|
2009-02-12 17:35:40 +07:00
|
|
|
struct root_domain *old_rd = NULL;
|
2008-01-26 03:08:18 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2008-01-26 03:08:18 +07:00
|
|
|
|
|
|
|
if (rq->rd) {
|
2009-02-12 17:35:40 +07:00
|
|
|
old_rd = rq->rd;
|
2008-01-26 03:08:18 +07:00
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
if (cpumask_test_cpu(rq->cpu, old_rd->online))
|
2008-06-05 02:04:05 +07:00
|
|
|
set_rq_offline(rq);
|
2008-01-26 03:08:18 +07:00
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
cpumask_clear_cpu(rq->cpu, old_rd->span);
|
2008-01-26 03:08:26 +07:00
|
|
|
|
2009-02-12 17:35:40 +07:00
|
|
|
/*
|
|
|
|
* If we dont want to free the old_rt yet then
|
|
|
|
* set old_rd to NULL to skip the freeing later
|
|
|
|
* in this function:
|
|
|
|
*/
|
|
|
|
if (!atomic_dec_and_test(&old_rd->refcount))
|
|
|
|
old_rd = NULL;
|
2008-01-26 03:08:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
atomic_inc(&rd->refcount);
|
|
|
|
rq->rd = rd;
|
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
cpumask_set_cpu(rq->cpu, rd->span);
|
2009-07-30 21:57:23 +07:00
|
|
|
if (cpumask_test_cpu(rq->cpu, cpu_active_mask))
|
2008-06-05 02:04:05 +07:00
|
|
|
set_rq_online(rq);
|
2008-01-26 03:08:18 +07:00
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2009-02-12 17:35:40 +07:00
|
|
|
|
|
|
|
if (old_rd)
|
|
|
|
free_rootdomain(old_rd);
|
2008-01-26 03:08:18 +07:00
|
|
|
}
|
|
|
|
|
2009-06-15 12:34:19 +07:00
|
|
|
static int init_rootdomain(struct root_domain *rd, bool bootmem)
|
2008-01-26 03:08:18 +07:00
|
|
|
{
|
2009-06-11 03:42:36 +07:00
|
|
|
gfp_t gfp = GFP_KERNEL;
|
|
|
|
|
2008-01-26 03:08:18 +07:00
|
|
|
memset(rd, 0, sizeof(*rd));
|
|
|
|
|
2009-06-11 03:42:36 +07:00
|
|
|
if (bootmem)
|
|
|
|
gfp = GFP_NOWAIT;
|
2008-11-24 23:05:05 +07:00
|
|
|
|
2009-06-11 03:42:36 +07:00
|
|
|
if (!alloc_cpumask_var(&rd->span, gfp))
|
2009-01-06 16:39:06 +07:00
|
|
|
goto out;
|
2009-06-11 03:42:36 +07:00
|
|
|
if (!alloc_cpumask_var(&rd->online, gfp))
|
2008-11-24 23:05:05 +07:00
|
|
|
goto free_span;
|
2009-06-11 03:42:36 +07:00
|
|
|
if (!alloc_cpumask_var(&rd->rto_mask, gfp))
|
2008-11-24 23:05:05 +07:00
|
|
|
goto free_online;
|
2008-05-13 02:21:01 +07:00
|
|
|
|
2009-06-11 12:41:22 +07:00
|
|
|
if (cpupri_init(&rd->cpupri, bootmem) != 0)
|
2008-11-24 23:05:13 +07:00
|
|
|
goto free_rto_mask;
|
2008-11-24 23:05:05 +07:00
|
|
|
return 0;
|
2008-05-13 02:21:01 +07:00
|
|
|
|
2008-11-24 23:05:13 +07:00
|
|
|
free_rto_mask:
|
|
|
|
free_cpumask_var(rd->rto_mask);
|
2008-11-24 23:05:05 +07:00
|
|
|
free_online:
|
|
|
|
free_cpumask_var(rd->online);
|
|
|
|
free_span:
|
|
|
|
free_cpumask_var(rd->span);
|
2009-01-06 16:39:06 +07:00
|
|
|
out:
|
2008-11-24 23:05:05 +07:00
|
|
|
return -ENOMEM;
|
2008-01-26 03:08:18 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void init_defrootdomain(void)
|
|
|
|
{
|
2008-11-24 23:05:05 +07:00
|
|
|
init_rootdomain(&def_root_domain, true);
|
|
|
|
|
2008-01-26 03:08:18 +07:00
|
|
|
atomic_set(&def_root_domain.refcount, 1);
|
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:26 +07:00
|
|
|
static struct root_domain *alloc_rootdomain(void)
|
2008-01-26 03:08:18 +07:00
|
|
|
{
|
|
|
|
struct root_domain *rd;
|
|
|
|
|
|
|
|
rd = kmalloc(sizeof(*rd), GFP_KERNEL);
|
|
|
|
if (!rd)
|
|
|
|
return NULL;
|
|
|
|
|
2008-11-24 23:05:05 +07:00
|
|
|
if (init_rootdomain(rd, false) != 0) {
|
|
|
|
kfree(rd);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-01-26 03:08:18 +07:00
|
|
|
|
|
|
|
return rd;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2008-01-26 03:08:19 +07:00
|
|
|
* Attach the domain 'sd' to 'cpu' as its base domain. Callers must
|
2005-04-17 05:20:36 +07:00
|
|
|
* hold the hotplug lock.
|
|
|
|
*/
|
2008-01-26 03:08:19 +07:00
|
|
|
static void
|
|
|
|
cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2005-06-26 04:57:25 +07:00
|
|
|
struct sched_domain *tmp;
|
|
|
|
|
2010-04-16 19:59:29 +07:00
|
|
|
for (tmp = sd; tmp; tmp = tmp->parent)
|
|
|
|
tmp->span_weight = cpumask_weight(sched_domain_span(tmp));
|
|
|
|
|
2005-06-26 04:57:25 +07:00
|
|
|
/* Remove the sched domains which do not contribute to scheduling. */
|
2008-11-06 08:45:16 +07:00
|
|
|
for (tmp = sd; tmp; ) {
|
2005-06-26 04:57:25 +07:00
|
|
|
struct sched_domain *parent = tmp->parent;
|
|
|
|
if (!parent)
|
|
|
|
break;
|
2008-11-06 08:45:16 +07:00
|
|
|
|
2006-10-03 15:14:08 +07:00
|
|
|
if (sd_parent_degenerate(tmp, parent)) {
|
2005-06-26 04:57:25 +07:00
|
|
|
tmp->parent = parent->parent;
|
2006-10-03 15:14:08 +07:00
|
|
|
if (parent->parent)
|
|
|
|
parent->parent->child = tmp;
|
2008-11-06 08:45:16 +07:00
|
|
|
} else
|
|
|
|
tmp = tmp->parent;
|
2005-06-26 04:57:25 +07:00
|
|
|
}
|
|
|
|
|
2006-10-03 15:14:08 +07:00
|
|
|
if (sd && sd_degenerate(sd)) {
|
2005-06-26 04:57:25 +07:00
|
|
|
sd = sd->parent;
|
2006-10-03 15:14:08 +07:00
|
|
|
if (sd)
|
|
|
|
sd->child = NULL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
sched_domain_debug(sd, cpu);
|
|
|
|
|
2008-01-26 03:08:18 +07:00
|
|
|
rq_attach_root(rq, rd);
|
2005-06-26 04:57:27 +07:00
|
|
|
rcu_assign_pointer(rq->sd, sd);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* cpus with isolated domains */
|
2008-11-24 23:05:12 +07:00
|
|
|
static cpumask_var_t cpu_isolated_map;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Setup the mask of cpus configured for isolated domains */
|
|
|
|
static int __init isolated_cpu_setup(char *str)
|
|
|
|
{
|
2009-12-02 10:39:16 +07:00
|
|
|
alloc_bootmem_cpumask_var(&cpu_isolated_map);
|
2008-12-13 18:25:51 +07:00
|
|
|
cpulist_parse(str, cpu_isolated_map);
|
2005-04-17 05:20:36 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:13 +07:00
|
|
|
__setup("isolcpus=", isolated_cpu_setup);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2006-12-10 17:20:07 +07:00
|
|
|
* init_sched_build_groups takes the cpumask we wish to span, and a pointer
|
|
|
|
* to a function which identifies what group(along with sched group) a CPU
|
2008-11-24 23:05:14 +07:00
|
|
|
* belongs to. The return value of group_fn must be a >= 0 and < nr_cpu_ids
|
|
|
|
* (due to the fact that we keep track of groups covered with a struct cpumask).
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* init_sched_build_groups will build a circular linked list of the groups
|
|
|
|
* covered by the given span, and will set each group's ->cpumask correctly,
|
|
|
|
* and ->cpu_power to 0.
|
|
|
|
*/
|
2006-10-03 15:14:06 +07:00
|
|
|
static void
|
2008-11-24 23:05:14 +07:00
|
|
|
init_sched_build_groups(const struct cpumask *span,
|
|
|
|
const struct cpumask *cpu_map,
|
|
|
|
int (*group_fn)(int cpu, const struct cpumask *cpu_map,
|
2008-04-05 08:11:11 +07:00
|
|
|
struct sched_group **sg,
|
2008-11-24 23:05:14 +07:00
|
|
|
struct cpumask *tmpmask),
|
|
|
|
struct cpumask *covered, struct cpumask *tmpmask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct sched_group *first = NULL, *last = NULL;
|
|
|
|
int i;
|
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
cpumask_clear(covered);
|
2008-04-05 08:11:11 +07:00
|
|
|
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, span) {
|
2006-12-10 17:20:07 +07:00
|
|
|
struct sched_group *sg;
|
2008-04-05 08:11:11 +07:00
|
|
|
int group = group_fn(i, cpu_map, &sg, tmpmask);
|
2005-04-17 05:20:36 +07:00
|
|
|
int j;
|
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
if (cpumask_test_cpu(i, covered))
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
cpumask_clear(sched_group_cpus(sg));
|
2009-09-01 15:34:39 +07:00
|
|
|
sg->cpu_power = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(j, span) {
|
2008-04-05 08:11:11 +07:00
|
|
|
if (group_fn(j, cpu_map, NULL, tmpmask) != group)
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
cpumask_set_cpu(j, covered);
|
2008-11-24 23:05:04 +07:00
|
|
|
cpumask_set_cpu(j, sched_group_cpus(sg));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
if (!first)
|
|
|
|
first = sg;
|
|
|
|
if (last)
|
|
|
|
last->next = sg;
|
|
|
|
last = sg;
|
|
|
|
}
|
|
|
|
last->next = first;
|
|
|
|
}
|
|
|
|
|
2005-09-07 05:18:14 +07:00
|
|
|
#define SD_NODES_PER_DOMAIN 16
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-09-07 05:18:14 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
[PATCH] scheduler cache-hot-autodetect
)
From: Ingo Molnar <mingo@elte.hu>
This is the latest version of the scheduler cache-hot-auto-tune patch.
The first problem was that detection time scaled with O(N^2), which is
unacceptable on larger SMP and NUMA systems. To solve this:
- I've added a 'domain distance' function, which is used to cache
measurement results. Each distance is only measured once. This means
that e.g. on NUMA distances of 0, 1 and 2 might be measured, on HT
distances 0 and 1, and on SMP distance 0 is measured. The code walks
the domain tree to determine the distance, so it automatically follows
whatever hierarchy an architecture sets up. This cuts down on the boot
time significantly and removes the O(N^2) limit. The only assumption
is that migration costs can be expressed as a function of domain
distance - this covers the overwhelming majority of existing systems,
and is a good guess even for more assymetric systems.
[ People hacking systems that have assymetries that break this
assumption (e.g. different CPU speeds) should experiment a bit with
the cpu_distance() function. Adding a ->migration_distance factor to
the domain structure would be one possible solution - but lets first
see the problem systems, if they exist at all. Lets not overdesign. ]
Another problem was that only a single cache-size was used for measuring
the cost of migration, and most architectures didnt set that variable
up. Furthermore, a single cache-size does not fit NUMA hierarchies with
L3 caches and does not fit HT setups, where different CPUs will often
have different 'effective cache sizes'. To solve this problem:
- Instead of relying on a single cache-size provided by the platform and
sticking to it, the code now auto-detects the 'effective migration
cost' between two measured CPUs, via iterating through a wide range of
cachesizes. The code searches for the maximum migration cost, which
occurs when the working set of the test-workload falls just below the
'effective cache size'. I.e. real-life optimized search is done for
the maximum migration cost, between two real CPUs.
This, amongst other things, has the positive effect hat if e.g. two
CPUs share a L2/L3 cache, a different (and accurate) migration cost
will be found than between two CPUs on the same system that dont share
any caches.
(The reliable measurement of migration costs is tricky - see the source
for details.)
Furthermore i've added various boot-time options to override/tune
migration behavior.
Firstly, there's a blanket override for autodetection:
migration_cost=1000,2000,3000
will override the depth 0/1/2 values with 1msec/2msec/3msec values.
Secondly, there's a global factor that can be used to increase (or
decrease) the autodetected values:
migration_factor=120
will increase the autodetected values by 20%. This option is useful to
tune things in a workload-dependent way - e.g. if a workload is
cache-insensitive then CPU utilization can be maximized by specifying
migration_factor=0.
I've tested the autodetection code quite extensively on x86, on 3
P3/Xeon/2MB, and the autodetected values look pretty good:
Dual Celeron (128K L2 cache):
---------------------
migration cost matrix (max_cache_size: 131072, cpu: 467 MHz):
---------------------
[00] [01]
[00]: - 1.7(1)
[01]: 1.7(1) -
---------------------
cacheflush times [2]: 0.0 (0) 1.7 (1784008)
---------------------
Here the slow memory subsystem dominates system performance, and even
though caches are small, the migration cost is 1.7 msecs.
Dual HT P4 (512K L2 cache):
---------------------
migration cost matrix (max_cache_size: 524288, cpu: 2379 MHz):
---------------------
[00] [01] [02] [03]
[00]: - 0.4(1) 0.0(0) 0.4(1)
[01]: 0.4(1) - 0.4(1) 0.0(0)
[02]: 0.0(0) 0.4(1) - 0.4(1)
[03]: 0.4(1) 0.0(0) 0.4(1) -
---------------------
cacheflush times [2]: 0.0 (33900) 0.4 (448514)
---------------------
Here it can be seen that there is no migration cost between two HT
siblings (CPU#0/2 and CPU#1/3 are separate physical CPUs). A fast memory
system makes inter-physical-CPU migration pretty cheap: 0.4 msecs.
8-way P3/Xeon [2MB L2 cache]:
---------------------
migration cost matrix (max_cache_size: 2097152, cpu: 700 MHz):
---------------------
[00] [01] [02] [03] [04] [05] [06] [07]
[00]: - 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[01]: 19.2(1) - 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[02]: 19.2(1) 19.2(1) - 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[03]: 19.2(1) 19.2(1) 19.2(1) - 19.2(1) 19.2(1) 19.2(1) 19.2(1)
[04]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) - 19.2(1) 19.2(1) 19.2(1)
[05]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) - 19.2(1) 19.2(1)
[06]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) - 19.2(1)
[07]: 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) 19.2(1) -
---------------------
cacheflush times [2]: 0.0 (0) 19.2 (19281756)
---------------------
This one has huge caches and a relatively slow memory subsystem - so the
migration cost is 19 msecs.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: Ken Chen <kenneth.w.chen@intel.com>
Cc: <wilder@us.ibm.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-12 16:05:30 +07:00
|
|
|
|
2005-09-07 05:18:14 +07:00
|
|
|
/**
|
|
|
|
* find_next_best_node - find the next node to include in a sched_domain
|
|
|
|
* @node: node whose sched_domain we're building
|
|
|
|
* @used_nodes: nodes already in the sched_domain
|
|
|
|
*
|
2007-12-05 21:46:09 +07:00
|
|
|
* Find the next node to include in a given scheduling domain. Simply
|
2005-09-07 05:18:14 +07:00
|
|
|
* finds the closest node not already in the @used_nodes map.
|
|
|
|
*
|
|
|
|
* Should use nodemask_t.
|
|
|
|
*/
|
2008-04-05 08:11:10 +07:00
|
|
|
static int find_next_best_node(int node, nodemask_t *used_nodes)
|
2005-09-07 05:18:14 +07:00
|
|
|
{
|
|
|
|
int i, n, val, min_val, best_node = 0;
|
|
|
|
|
|
|
|
min_val = INT_MAX;
|
|
|
|
|
2008-05-13 02:21:12 +07:00
|
|
|
for (i = 0; i < nr_node_ids; i++) {
|
2005-09-07 05:18:14 +07:00
|
|
|
/* Start at @node */
|
2008-05-13 02:21:12 +07:00
|
|
|
n = (node + i) % nr_node_ids;
|
2005-09-07 05:18:14 +07:00
|
|
|
|
|
|
|
if (!nr_cpus_node(n))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Skip already used nodes */
|
2008-04-05 08:11:10 +07:00
|
|
|
if (node_isset(n, *used_nodes))
|
2005-09-07 05:18:14 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Simple min distance search */
|
|
|
|
val = node_distance(node, n);
|
|
|
|
|
|
|
|
if (val < min_val) {
|
|
|
|
min_val = val;
|
|
|
|
best_node = n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-05 08:11:10 +07:00
|
|
|
node_set(best_node, *used_nodes);
|
2005-09-07 05:18:14 +07:00
|
|
|
return best_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sched_domain_node_span - get a cpumask for a node's sched_domain
|
|
|
|
* @node: node whose cpumask we're constructing
|
2008-04-23 00:07:22 +07:00
|
|
|
* @span: resulting cpumask
|
2005-09-07 05:18:14 +07:00
|
|
|
*
|
2007-12-05 21:46:09 +07:00
|
|
|
* Given a node, construct a good cpumask for its sched_domain to span. It
|
2005-09-07 05:18:14 +07:00
|
|
|
* should be one that prevents unnecessary balancing, but also spreads tasks
|
|
|
|
* out optimally.
|
|
|
|
*/
|
2008-11-24 23:05:14 +07:00
|
|
|
static void sched_domain_node_span(int node, struct cpumask *span)
|
2005-09-07 05:18:14 +07:00
|
|
|
{
|
2008-04-05 08:11:10 +07:00
|
|
|
nodemask_t used_nodes;
|
2006-07-03 14:25:40 +07:00
|
|
|
int i;
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2009-01-01 09:08:45 +07:00
|
|
|
cpumask_clear(span);
|
2008-04-05 08:11:10 +07:00
|
|
|
nodes_clear(used_nodes);
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2009-01-01 09:08:45 +07:00
|
|
|
cpumask_or(span, span, cpumask_of_node(node));
|
2008-04-05 08:11:10 +07:00
|
|
|
node_set(node, used_nodes);
|
2005-09-07 05:18:14 +07:00
|
|
|
|
|
|
|
for (i = 1; i < SD_NODES_PER_DOMAIN; i++) {
|
2008-04-05 08:11:10 +07:00
|
|
|
int next_node = find_next_best_node(node, &used_nodes);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2009-01-01 09:08:45 +07:00
|
|
|
cpumask_or(span, span, cpumask_of_node(next_node));
|
2005-09-07 05:18:14 +07:00
|
|
|
}
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_NUMA */
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2006-06-27 16:54:42 +07:00
|
|
|
int sched_smt_power_savings = 0, sched_mc_power_savings = 0;
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
/*
|
|
|
|
* The cpus mask in sched_group and sched_domain hangs off the end.
|
2009-05-19 14:22:19 +07:00
|
|
|
*
|
|
|
|
* ( See the the comments in include/linux/sched.h:struct sched_group
|
|
|
|
* and struct sched_domain. )
|
2008-11-24 23:05:04 +07:00
|
|
|
*/
|
|
|
|
struct static_sched_group {
|
|
|
|
struct sched_group sg;
|
|
|
|
DECLARE_BITMAP(cpus, CONFIG_NR_CPUS);
|
|
|
|
};
|
|
|
|
|
|
|
|
struct static_sched_domain {
|
|
|
|
struct sched_domain sd;
|
|
|
|
DECLARE_BITMAP(span, CONFIG_NR_CPUS);
|
|
|
|
};
|
|
|
|
|
2009-08-18 17:51:52 +07:00
|
|
|
struct s_data {
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
int sd_allnodes;
|
|
|
|
cpumask_var_t domainspan;
|
|
|
|
cpumask_var_t covered;
|
|
|
|
cpumask_var_t notcovered;
|
|
|
|
#endif
|
|
|
|
cpumask_var_t nodemask;
|
|
|
|
cpumask_var_t this_sibling_map;
|
|
|
|
cpumask_var_t this_core_map;
|
|
|
|
cpumask_var_t send_covered;
|
|
|
|
cpumask_var_t tmpmask;
|
|
|
|
struct sched_group **sched_group_nodes;
|
|
|
|
struct root_domain *rd;
|
|
|
|
};
|
|
|
|
|
2009-08-18 17:53:00 +07:00
|
|
|
enum s_alloc {
|
|
|
|
sa_sched_groups = 0,
|
|
|
|
sa_rootdomain,
|
|
|
|
sa_tmpmask,
|
|
|
|
sa_send_covered,
|
|
|
|
sa_this_core_map,
|
|
|
|
sa_this_sibling_map,
|
|
|
|
sa_nodemask,
|
|
|
|
sa_sched_group_nodes,
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
sa_notcovered,
|
|
|
|
sa_covered,
|
|
|
|
sa_domainspan,
|
|
|
|
#endif
|
|
|
|
sa_none,
|
|
|
|
};
|
|
|
|
|
2005-09-07 05:18:14 +07:00
|
|
|
/*
|
2006-07-03 14:25:40 +07:00
|
|
|
* SMT sched-domains:
|
2005-09-07 05:18:14 +07:00
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SCHED_SMT
|
2008-11-24 23:05:04 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_domain, cpu_domains);
|
2009-10-29 20:34:13 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_group, sched_groups);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2007-12-05 21:46:09 +07:00
|
|
|
static int
|
2008-11-24 23:05:14 +07:00
|
|
|
cpu_to_cpu_group(int cpu, const struct cpumask *cpu_map,
|
|
|
|
struct sched_group **sg, struct cpumask *unused)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-12-10 17:20:07 +07:00
|
|
|
if (sg)
|
2009-10-29 20:34:13 +07:00
|
|
|
*sg = &per_cpu(sched_groups, cpu).sg;
|
2005-04-17 05:20:36 +07:00
|
|
|
return cpu;
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_SCHED_SMT */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-07-03 14:25:40 +07:00
|
|
|
/*
|
|
|
|
* multi-core sched-domains:
|
|
|
|
*/
|
2006-03-27 16:15:22 +07:00
|
|
|
#ifdef CONFIG_SCHED_MC
|
2008-11-24 23:05:04 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_domain, core_domains);
|
|
|
|
static DEFINE_PER_CPU(struct static_sched_group, sched_group_core);
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_SCHED_MC */
|
2006-03-27 16:15:22 +07:00
|
|
|
|
|
|
|
#if defined(CONFIG_SCHED_MC) && defined(CONFIG_SCHED_SMT)
|
2007-12-05 21:46:09 +07:00
|
|
|
static int
|
2008-11-24 23:05:14 +07:00
|
|
|
cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
|
|
|
|
struct sched_group **sg, struct cpumask *mask)
|
2006-03-27 16:15:22 +07:00
|
|
|
{
|
2006-12-10 17:20:07 +07:00
|
|
|
int group;
|
2008-04-05 08:11:11 +07:00
|
|
|
|
2009-03-13 11:19:46 +07:00
|
|
|
cpumask_and(mask, topology_thread_cpumask(cpu), cpu_map);
|
2008-11-24 23:05:14 +07:00
|
|
|
group = cpumask_first(mask);
|
2006-12-10 17:20:07 +07:00
|
|
|
if (sg)
|
2008-11-24 23:05:04 +07:00
|
|
|
*sg = &per_cpu(sched_group_core, group).sg;
|
2006-12-10 17:20:07 +07:00
|
|
|
return group;
|
2006-03-27 16:15:22 +07:00
|
|
|
}
|
|
|
|
#elif defined(CONFIG_SCHED_MC)
|
2007-12-05 21:46:09 +07:00
|
|
|
static int
|
2008-11-24 23:05:14 +07:00
|
|
|
cpu_to_core_group(int cpu, const struct cpumask *cpu_map,
|
|
|
|
struct sched_group **sg, struct cpumask *unused)
|
2006-03-27 16:15:22 +07:00
|
|
|
{
|
2006-12-10 17:20:07 +07:00
|
|
|
if (sg)
|
2008-11-24 23:05:04 +07:00
|
|
|
*sg = &per_cpu(sched_group_core, cpu).sg;
|
2006-03-27 16:15:22 +07:00
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_domain, phys_domains);
|
|
|
|
static DEFINE_PER_CPU(struct static_sched_group, sched_group_phys);
|
2006-07-03 14:25:40 +07:00
|
|
|
|
2007-12-05 21:46:09 +07:00
|
|
|
static int
|
2008-11-24 23:05:14 +07:00
|
|
|
cpu_to_phys_group(int cpu, const struct cpumask *cpu_map,
|
|
|
|
struct sched_group **sg, struct cpumask *mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-12-10 17:20:07 +07:00
|
|
|
int group;
|
2006-07-03 14:25:40 +07:00
|
|
|
#ifdef CONFIG_SCHED_MC
|
2009-01-01 09:08:45 +07:00
|
|
|
cpumask_and(mask, cpu_coregroup_mask(cpu), cpu_map);
|
2008-11-24 23:05:14 +07:00
|
|
|
group = cpumask_first(mask);
|
2006-03-27 16:15:22 +07:00
|
|
|
#elif defined(CONFIG_SCHED_SMT)
|
2009-03-13 11:19:46 +07:00
|
|
|
cpumask_and(mask, topology_thread_cpumask(cpu), cpu_map);
|
2008-11-24 23:05:14 +07:00
|
|
|
group = cpumask_first(mask);
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
2006-12-10 17:20:07 +07:00
|
|
|
group = cpu;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2006-12-10 17:20:07 +07:00
|
|
|
if (sg)
|
2008-11-24 23:05:04 +07:00
|
|
|
*sg = &per_cpu(sched_group_phys, group).sg;
|
2006-12-10 17:20:07 +07:00
|
|
|
return group;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
/*
|
2005-09-07 05:18:14 +07:00
|
|
|
* The init_sched_build_groups can't handle what we want to do with node
|
|
|
|
* groups, so roll our own. Now each node has its own list of groups which
|
|
|
|
* gets dynamically allocated.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-01-11 07:04:16 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_domain, node_domains);
|
2008-04-05 08:11:04 +07:00
|
|
|
static struct sched_group ***sched_group_nodes_bycpu;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-01-11 07:04:16 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_domain, allnodes_domains);
|
2008-11-24 23:05:04 +07:00
|
|
|
static DEFINE_PER_CPU(struct static_sched_group, sched_group_allnodes);
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
static int cpu_to_allnodes_group(int cpu, const struct cpumask *cpu_map,
|
|
|
|
struct sched_group **sg,
|
|
|
|
struct cpumask *nodemask)
|
2005-09-07 05:18:14 +07:00
|
|
|
{
|
2006-12-10 17:20:07 +07:00
|
|
|
int group;
|
|
|
|
|
2009-01-01 09:08:45 +07:00
|
|
|
cpumask_and(nodemask, cpumask_of_node(cpu_to_node(cpu)), cpu_map);
|
2008-11-24 23:05:14 +07:00
|
|
|
group = cpumask_first(nodemask);
|
2006-12-10 17:20:07 +07:00
|
|
|
|
|
|
|
if (sg)
|
2008-11-24 23:05:04 +07:00
|
|
|
*sg = &per_cpu(sched_group_allnodes, group).sg;
|
2006-12-10 17:20:07 +07:00
|
|
|
return group;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-12-10 17:20:07 +07:00
|
|
|
|
2006-03-27 16:15:23 +07:00
|
|
|
static void init_numa_sched_groups_power(struct sched_group *group_head)
|
|
|
|
{
|
|
|
|
struct sched_group *sg = group_head;
|
|
|
|
int j;
|
|
|
|
|
|
|
|
if (!sg)
|
|
|
|
return;
|
2007-10-15 22:00:14 +07:00
|
|
|
do {
|
2008-11-24 23:05:04 +07:00
|
|
|
for_each_cpu(j, sched_group_cpus(sg)) {
|
2007-10-15 22:00:14 +07:00
|
|
|
struct sched_domain *sd;
|
2006-03-27 16:15:23 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
sd = &per_cpu(phys_domains, j).sd;
|
2009-04-15 08:59:10 +07:00
|
|
|
if (j != group_first_cpu(sd->groups)) {
|
2007-10-15 22:00:14 +07:00
|
|
|
/*
|
|
|
|
* Only add "power" once for each
|
|
|
|
* physical package.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
2006-03-27 16:15:23 +07:00
|
|
|
|
2009-09-01 15:34:39 +07:00
|
|
|
sg->cpu_power += sd->groups->cpu_power;
|
2007-10-15 22:00:14 +07:00
|
|
|
}
|
|
|
|
sg = sg->next;
|
|
|
|
} while (sg != group_head);
|
2006-03-27 16:15:23 +07:00
|
|
|
}
|
2009-08-18 18:01:11 +07:00
|
|
|
|
|
|
|
static int build_numa_sched_groups(struct s_data *d,
|
|
|
|
const struct cpumask *cpu_map, int num)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd;
|
|
|
|
struct sched_group *sg, *prev;
|
|
|
|
int n, j;
|
|
|
|
|
|
|
|
cpumask_clear(d->covered);
|
|
|
|
cpumask_and(d->nodemask, cpumask_of_node(num), cpu_map);
|
|
|
|
if (cpumask_empty(d->nodemask)) {
|
|
|
|
d->sched_group_nodes[num] = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
sched_domain_node_span(num, d->domainspan);
|
|
|
|
cpumask_and(d->domainspan, d->domainspan, cpu_map);
|
|
|
|
|
|
|
|
sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
|
|
|
|
GFP_KERNEL, num);
|
|
|
|
if (!sg) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_WARNING "Can not alloc domain group for node %d\n",
|
|
|
|
num);
|
2009-08-18 18:01:11 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
d->sched_group_nodes[num] = sg;
|
|
|
|
|
|
|
|
for_each_cpu(j, d->nodemask) {
|
|
|
|
sd = &per_cpu(node_domains, j).sd;
|
|
|
|
sd->groups = sg;
|
|
|
|
}
|
|
|
|
|
2009-09-01 15:34:39 +07:00
|
|
|
sg->cpu_power = 0;
|
2009-08-18 18:01:11 +07:00
|
|
|
cpumask_copy(sched_group_cpus(sg), d->nodemask);
|
|
|
|
sg->next = sg;
|
|
|
|
cpumask_or(d->covered, d->covered, d->nodemask);
|
|
|
|
|
|
|
|
prev = sg;
|
|
|
|
for (j = 0; j < nr_node_ids; j++) {
|
|
|
|
n = (num + j) % nr_node_ids;
|
|
|
|
cpumask_complement(d->notcovered, d->covered);
|
|
|
|
cpumask_and(d->tmpmask, d->notcovered, cpu_map);
|
|
|
|
cpumask_and(d->tmpmask, d->tmpmask, d->domainspan);
|
|
|
|
if (cpumask_empty(d->tmpmask))
|
|
|
|
break;
|
|
|
|
cpumask_and(d->tmpmask, d->tmpmask, cpumask_of_node(n));
|
|
|
|
if (cpumask_empty(d->tmpmask))
|
|
|
|
continue;
|
|
|
|
sg = kmalloc_node(sizeof(struct sched_group) + cpumask_size(),
|
|
|
|
GFP_KERNEL, num);
|
|
|
|
if (!sg) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_WARNING
|
|
|
|
"Can not alloc domain group for node %d\n", j);
|
2009-08-18 18:01:11 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-09-01 15:34:39 +07:00
|
|
|
sg->cpu_power = 0;
|
2009-08-18 18:01:11 +07:00
|
|
|
cpumask_copy(sched_group_cpus(sg), d->tmpmask);
|
|
|
|
sg->next = prev->next;
|
|
|
|
cpumask_or(d->covered, d->covered, d->tmpmask);
|
|
|
|
prev->next = sg;
|
|
|
|
prev = sg;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_NUMA */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-10-03 15:14:06 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2006-06-27 16:54:38 +07:00
|
|
|
/* Free memory allocated for various sched_group structures */
|
2008-11-24 23:05:14 +07:00
|
|
|
static void free_sched_groups(const struct cpumask *cpu_map,
|
|
|
|
struct cpumask *nodemask)
|
2006-06-27 16:54:38 +07:00
|
|
|
{
|
2006-10-03 15:14:06 +07:00
|
|
|
int cpu, i;
|
2006-06-27 16:54:38 +07:00
|
|
|
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(cpu, cpu_map) {
|
2006-06-27 16:54:38 +07:00
|
|
|
struct sched_group **sched_group_nodes
|
|
|
|
= sched_group_nodes_bycpu[cpu];
|
|
|
|
|
|
|
|
if (!sched_group_nodes)
|
|
|
|
continue;
|
|
|
|
|
2008-05-13 02:21:12 +07:00
|
|
|
for (i = 0; i < nr_node_ids; i++) {
|
2006-06-27 16:54:38 +07:00
|
|
|
struct sched_group *oldsg, *sg = sched_group_nodes[i];
|
|
|
|
|
2009-01-01 09:08:45 +07:00
|
|
|
cpumask_and(nodemask, cpumask_of_node(i), cpu_map);
|
2008-11-24 23:05:14 +07:00
|
|
|
if (cpumask_empty(nodemask))
|
2006-06-27 16:54:38 +07:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sg == NULL)
|
|
|
|
continue;
|
|
|
|
sg = sg->next;
|
|
|
|
next_sg:
|
|
|
|
oldsg = sg;
|
|
|
|
sg = sg->next;
|
|
|
|
kfree(oldsg);
|
|
|
|
if (oldsg != sched_group_nodes[i])
|
|
|
|
goto next_sg;
|
|
|
|
}
|
|
|
|
kfree(sched_group_nodes);
|
|
|
|
sched_group_nodes_bycpu[cpu] = NULL;
|
|
|
|
}
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFIG_NUMA */
|
2008-11-24 23:05:14 +07:00
|
|
|
static void free_sched_groups(const struct cpumask *cpu_map,
|
|
|
|
struct cpumask *nodemask)
|
2006-10-03 15:14:06 +07:00
|
|
|
{
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_NUMA */
|
2006-06-27 16:54:38 +07:00
|
|
|
|
2006-10-03 15:14:09 +07:00
|
|
|
/*
|
|
|
|
* Initialize sched groups cpu_power.
|
|
|
|
*
|
|
|
|
* cpu_power indicates the capacity of sched group, which is used while
|
|
|
|
* distributing the load between different sched groups in a sched domain.
|
|
|
|
* Typically cpu_power for all the groups in a sched domain will be same unless
|
|
|
|
* there are asymmetries in the topology. If there are asymmetries, group
|
|
|
|
* having more cpu_power will pickup more load compared to the group having
|
|
|
|
* less cpu_power.
|
|
|
|
*/
|
|
|
|
static void init_sched_groups_power(int cpu, struct sched_domain *sd)
|
|
|
|
{
|
|
|
|
struct sched_domain *child;
|
|
|
|
struct sched_group *group;
|
2009-09-01 15:34:32 +07:00
|
|
|
long power;
|
|
|
|
int weight;
|
2006-10-03 15:14:09 +07:00
|
|
|
|
|
|
|
WARN_ON(!sd || !sd->groups);
|
|
|
|
|
2009-04-15 08:59:10 +07:00
|
|
|
if (cpu != group_first_cpu(sd->groups))
|
2006-10-03 15:14:09 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
child = sd->child;
|
|
|
|
|
2009-09-01 15:34:39 +07:00
|
|
|
sd->groups->cpu_power = 0;
|
2007-05-08 14:32:57 +07:00
|
|
|
|
2009-09-01 15:34:32 +07:00
|
|
|
if (!child) {
|
|
|
|
power = SCHED_LOAD_SCALE;
|
|
|
|
weight = cpumask_weight(sched_domain_span(sd));
|
|
|
|
/*
|
|
|
|
* SMT siblings share the power of a single core.
|
2009-09-01 15:34:35 +07:00
|
|
|
* Usually multiple threads get a better yield out of
|
|
|
|
* that one core than a single thread would have,
|
|
|
|
* reflect that in sd->smt_gain.
|
2009-09-01 15:34:32 +07:00
|
|
|
*/
|
2009-09-01 15:34:35 +07:00
|
|
|
if ((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) {
|
|
|
|
power *= sd->smt_gain;
|
2009-09-01 15:34:32 +07:00
|
|
|
power /= weight;
|
2009-09-01 15:34:35 +07:00
|
|
|
power >>= SCHED_LOAD_SHIFT;
|
|
|
|
}
|
2009-09-01 15:34:39 +07:00
|
|
|
sd->groups->cpu_power += power;
|
2006-10-03 15:14:09 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-09-01 15:34:32 +07:00
|
|
|
* Add cpu_power of each child group to this groups cpu_power.
|
2006-10-03 15:14:09 +07:00
|
|
|
*/
|
|
|
|
group = child->groups;
|
|
|
|
do {
|
2009-09-01 15:34:39 +07:00
|
|
|
sd->groups->cpu_power += group->cpu_power;
|
2006-10-03 15:14:09 +07:00
|
|
|
group = group->next;
|
|
|
|
} while (group != child->groups);
|
|
|
|
}
|
|
|
|
|
2008-04-05 08:11:11 +07:00
|
|
|
/*
|
|
|
|
* Initializers for schedule domains
|
|
|
|
* Non-inlined to reduce accumulated stack pressure in build_sched_domains()
|
|
|
|
*/
|
|
|
|
|
2008-10-09 16:35:51 +07:00
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
# define SD_INIT_NAME(sd, type) sd->name = #type
|
|
|
|
#else
|
|
|
|
# define SD_INIT_NAME(sd, type) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2008-04-05 08:11:11 +07:00
|
|
|
#define SD_INIT(sd, type) sd_init_##type(sd)
|
2008-10-09 16:35:51 +07:00
|
|
|
|
2008-04-05 08:11:11 +07:00
|
|
|
#define SD_INIT_FUNC(type) \
|
|
|
|
static noinline void sd_init_##type(struct sched_domain *sd) \
|
|
|
|
{ \
|
|
|
|
memset(sd, 0, sizeof(*sd)); \
|
|
|
|
*sd = SD_##type##_INIT; \
|
2008-04-15 12:04:23 +07:00
|
|
|
sd->level = SD_LV_##type; \
|
2008-10-09 16:35:51 +07:00
|
|
|
SD_INIT_NAME(sd, type); \
|
2008-04-05 08:11:11 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
SD_INIT_FUNC(CPU)
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
SD_INIT_FUNC(ALLNODES)
|
|
|
|
SD_INIT_FUNC(NODE)
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_SMT
|
|
|
|
SD_INIT_FUNC(SIBLING)
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_MC
|
|
|
|
SD_INIT_FUNC(MC)
|
|
|
|
#endif
|
|
|
|
|
2008-04-15 12:04:23 +07:00
|
|
|
static int default_relax_domain_level = -1;
|
|
|
|
|
|
|
|
static int __init setup_relax_domain_level(char *str)
|
|
|
|
{
|
2008-05-13 09:27:17 +07:00
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
val = simple_strtoul(str, NULL, 0);
|
|
|
|
if (val < SD_LV_MAX)
|
|
|
|
default_relax_domain_level = val;
|
|
|
|
|
2008-04-15 12:04:23 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("relax_domain_level=", setup_relax_domain_level);
|
|
|
|
|
|
|
|
static void set_domain_attribute(struct sched_domain *sd,
|
|
|
|
struct sched_domain_attr *attr)
|
|
|
|
{
|
|
|
|
int request;
|
|
|
|
|
|
|
|
if (!attr || attr->relax_domain_level < 0) {
|
|
|
|
if (default_relax_domain_level < 0)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
request = default_relax_domain_level;
|
|
|
|
} else
|
|
|
|
request = attr->relax_domain_level;
|
|
|
|
if (request < sd->level) {
|
|
|
|
/* turn off idle balance on this domain */
|
sched: Merge select_task_rq_fair() and sched_balance_self()
The problem with wake_idle() is that is doesn't respect things like
cpu_power, which means it doesn't deal well with SMT nor the recent
RT interaction.
To cure this, it needs to do what sched_balance_self() does, which
leads to the possibility of merging select_task_rq_fair() and
sched_balance_self().
Modify sched_balance_self() to:
- update_shares() when walking up the domain tree,
(it only called it for the top domain, but it should
have done this anyway), which allows us to remove
this ugly bit from try_to_wake_up().
- do wake_affine() on the smallest domain that contains
both this (the waking) and the prev (the wakee) cpu for
WAKE invocations.
Then use the top-down balance steps it had to replace wake_idle().
This leads to the dissapearance of SD_WAKE_BALANCE and
SD_WAKE_IDLE_FAR, with SD_WAKE_IDLE replaced with SD_BALANCE_WAKE.
SD_WAKE_AFFINE needs SD_BALANCE_WAKE to be effective.
Touch all topology bits to replace the old with new SD flags --
platforms might need re-tuning, enabling SD_BALANCE_WAKE
conditionally on a NUMA distance seems like a good additional
feature, magny-core and small nehalem systems would want this
enabled, systems with slow interconnects would not.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-10 18:50:02 +07:00
|
|
|
sd->flags &= ~(SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
|
2008-04-15 12:04:23 +07:00
|
|
|
} else {
|
|
|
|
/* turn on idle balance on this domain */
|
sched: Merge select_task_rq_fair() and sched_balance_self()
The problem with wake_idle() is that is doesn't respect things like
cpu_power, which means it doesn't deal well with SMT nor the recent
RT interaction.
To cure this, it needs to do what sched_balance_self() does, which
leads to the possibility of merging select_task_rq_fair() and
sched_balance_self().
Modify sched_balance_self() to:
- update_shares() when walking up the domain tree,
(it only called it for the top domain, but it should
have done this anyway), which allows us to remove
this ugly bit from try_to_wake_up().
- do wake_affine() on the smallest domain that contains
both this (the waking) and the prev (the wakee) cpu for
WAKE invocations.
Then use the top-down balance steps it had to replace wake_idle().
This leads to the dissapearance of SD_WAKE_BALANCE and
SD_WAKE_IDLE_FAR, with SD_WAKE_IDLE replaced with SD_BALANCE_WAKE.
SD_WAKE_AFFINE needs SD_BALANCE_WAKE to be effective.
Touch all topology bits to replace the old with new SD flags --
platforms might need re-tuning, enabling SD_BALANCE_WAKE
conditionally on a NUMA distance seems like a good additional
feature, magny-core and small nehalem systems would want this
enabled, systems with slow interconnects would not.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-10 18:50:02 +07:00
|
|
|
sd->flags |= (SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
|
2008-04-15 12:04:23 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-18 17:53:00 +07:00
|
|
|
static void __free_domain_allocs(struct s_data *d, enum s_alloc what,
|
|
|
|
const struct cpumask *cpu_map)
|
|
|
|
{
|
|
|
|
switch (what) {
|
|
|
|
case sa_sched_groups:
|
|
|
|
free_sched_groups(cpu_map, d->tmpmask); /* fall through */
|
|
|
|
d->sched_group_nodes = NULL;
|
|
|
|
case sa_rootdomain:
|
|
|
|
free_rootdomain(d->rd); /* fall through */
|
|
|
|
case sa_tmpmask:
|
|
|
|
free_cpumask_var(d->tmpmask); /* fall through */
|
|
|
|
case sa_send_covered:
|
|
|
|
free_cpumask_var(d->send_covered); /* fall through */
|
|
|
|
case sa_this_core_map:
|
|
|
|
free_cpumask_var(d->this_core_map); /* fall through */
|
|
|
|
case sa_this_sibling_map:
|
|
|
|
free_cpumask_var(d->this_sibling_map); /* fall through */
|
|
|
|
case sa_nodemask:
|
|
|
|
free_cpumask_var(d->nodemask); /* fall through */
|
|
|
|
case sa_sched_group_nodes:
|
2005-09-07 05:18:14 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2009-08-18 17:53:00 +07:00
|
|
|
kfree(d->sched_group_nodes); /* fall through */
|
|
|
|
case sa_notcovered:
|
|
|
|
free_cpumask_var(d->notcovered); /* fall through */
|
|
|
|
case sa_covered:
|
|
|
|
free_cpumask_var(d->covered); /* fall through */
|
|
|
|
case sa_domainspan:
|
|
|
|
free_cpumask_var(d->domainspan); /* fall through */
|
2008-11-24 23:05:03 +07:00
|
|
|
#endif
|
2009-08-18 17:53:00 +07:00
|
|
|
case sa_none:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-11-24 23:05:03 +07:00
|
|
|
|
2009-08-18 17:53:00 +07:00
|
|
|
static enum s_alloc __visit_domain_allocation_hell(struct s_data *d,
|
|
|
|
const struct cpumask *cpu_map)
|
|
|
|
{
|
2008-11-24 23:05:03 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2009-08-18 17:53:00 +07:00
|
|
|
if (!alloc_cpumask_var(&d->domainspan, GFP_KERNEL))
|
|
|
|
return sa_none;
|
|
|
|
if (!alloc_cpumask_var(&d->covered, GFP_KERNEL))
|
|
|
|
return sa_domainspan;
|
|
|
|
if (!alloc_cpumask_var(&d->notcovered, GFP_KERNEL))
|
|
|
|
return sa_covered;
|
|
|
|
/* Allocate the per-node list of sched groups */
|
|
|
|
d->sched_group_nodes = kcalloc(nr_node_ids,
|
|
|
|
sizeof(struct sched_group *), GFP_KERNEL);
|
|
|
|
if (!d->sched_group_nodes) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_WARNING "Can not alloc sched group node list\n");
|
2009-08-18 17:53:00 +07:00
|
|
|
return sa_notcovered;
|
2005-09-07 05:18:14 +07:00
|
|
|
}
|
2009-08-18 17:53:00 +07:00
|
|
|
sched_group_nodes_bycpu[cpumask_first(cpu_map)] = d->sched_group_nodes;
|
2005-09-07 05:18:14 +07:00
|
|
|
#endif
|
2009-08-18 17:53:00 +07:00
|
|
|
if (!alloc_cpumask_var(&d->nodemask, GFP_KERNEL))
|
|
|
|
return sa_sched_group_nodes;
|
|
|
|
if (!alloc_cpumask_var(&d->this_sibling_map, GFP_KERNEL))
|
|
|
|
return sa_nodemask;
|
|
|
|
if (!alloc_cpumask_var(&d->this_core_map, GFP_KERNEL))
|
|
|
|
return sa_this_sibling_map;
|
|
|
|
if (!alloc_cpumask_var(&d->send_covered, GFP_KERNEL))
|
|
|
|
return sa_this_core_map;
|
|
|
|
if (!alloc_cpumask_var(&d->tmpmask, GFP_KERNEL))
|
|
|
|
return sa_send_covered;
|
|
|
|
d->rd = alloc_rootdomain();
|
|
|
|
if (!d->rd) {
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_WARNING "Cannot alloc root domain\n");
|
2009-08-18 17:53:00 +07:00
|
|
|
return sa_tmpmask;
|
2008-01-26 03:08:18 +07:00
|
|
|
}
|
2009-08-18 17:53:00 +07:00
|
|
|
return sa_rootdomain;
|
|
|
|
}
|
2008-01-26 03:08:18 +07:00
|
|
|
|
2009-08-18 17:54:06 +07:00
|
|
|
static struct sched_domain *__build_numa_sched_domains(struct s_data *d,
|
|
|
|
const struct cpumask *cpu_map, struct sched_domain_attr *attr, int i)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd = NULL;
|
2008-04-05 08:11:11 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2009-08-18 17:54:06 +07:00
|
|
|
struct sched_domain *parent;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-08-18 17:54:06 +07:00
|
|
|
d->sd_allnodes = 0;
|
|
|
|
if (cpumask_weight(cpu_map) >
|
|
|
|
SD_NODES_PER_DOMAIN * cpumask_weight(d->nodemask)) {
|
|
|
|
sd = &per_cpu(allnodes_domains, i).sd;
|
|
|
|
SD_INIT(sd, ALLNODES);
|
2008-04-15 12:04:23 +07:00
|
|
|
set_domain_attribute(sd, attr);
|
2009-08-18 17:54:06 +07:00
|
|
|
cpumask_copy(sched_domain_span(sd), cpu_map);
|
|
|
|
cpu_to_allnodes_group(i, cpu_map, &sd->groups, d->tmpmask);
|
|
|
|
d->sd_allnodes = 1;
|
|
|
|
}
|
|
|
|
parent = sd;
|
|
|
|
|
|
|
|
sd = &per_cpu(node_domains, i).sd;
|
|
|
|
SD_INIT(sd, NODE);
|
|
|
|
set_domain_attribute(sd, attr);
|
|
|
|
sched_domain_node_span(cpu_to_node(i), sched_domain_span(sd));
|
|
|
|
sd->parent = parent;
|
|
|
|
if (parent)
|
|
|
|
parent->child = sd;
|
|
|
|
cpumask_and(sched_domain_span(sd), sched_domain_span(sd), cpu_map);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2009-08-18 17:54:06 +07:00
|
|
|
return sd;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-08-18 17:54:55 +07:00
|
|
|
static struct sched_domain *__build_cpu_sched_domain(struct s_data *d,
|
|
|
|
const struct cpumask *cpu_map, struct sched_domain_attr *attr,
|
|
|
|
struct sched_domain *parent, int i)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd;
|
|
|
|
sd = &per_cpu(phys_domains, i).sd;
|
|
|
|
SD_INIT(sd, CPU);
|
|
|
|
set_domain_attribute(sd, attr);
|
|
|
|
cpumask_copy(sched_domain_span(sd), d->nodemask);
|
|
|
|
sd->parent = parent;
|
|
|
|
if (parent)
|
|
|
|
parent->child = sd;
|
|
|
|
cpu_to_phys_group(i, cpu_map, &sd->groups, d->tmpmask);
|
|
|
|
return sd;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-08-18 17:56:14 +07:00
|
|
|
static struct sched_domain *__build_mc_sched_domain(struct s_data *d,
|
|
|
|
const struct cpumask *cpu_map, struct sched_domain_attr *attr,
|
|
|
|
struct sched_domain *parent, int i)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd = parent;
|
2006-03-27 16:15:22 +07:00
|
|
|
#ifdef CONFIG_SCHED_MC
|
2009-08-18 17:56:14 +07:00
|
|
|
sd = &per_cpu(core_domains, i).sd;
|
|
|
|
SD_INIT(sd, MC);
|
|
|
|
set_domain_attribute(sd, attr);
|
|
|
|
cpumask_and(sched_domain_span(sd), cpu_map, cpu_coregroup_mask(i));
|
|
|
|
sd->parent = parent;
|
|
|
|
parent->child = sd;
|
|
|
|
cpu_to_core_group(i, cpu_map, &sd->groups, d->tmpmask);
|
2006-03-27 16:15:22 +07:00
|
|
|
#endif
|
2009-08-18 17:56:14 +07:00
|
|
|
return sd;
|
|
|
|
}
|
2006-03-27 16:15:22 +07:00
|
|
|
|
2009-08-18 17:57:03 +07:00
|
|
|
static struct sched_domain *__build_smt_sched_domain(struct s_data *d,
|
|
|
|
const struct cpumask *cpu_map, struct sched_domain_attr *attr,
|
|
|
|
struct sched_domain *parent, int i)
|
|
|
|
{
|
|
|
|
struct sched_domain *sd = parent;
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SCHED_SMT
|
2009-08-18 17:57:03 +07:00
|
|
|
sd = &per_cpu(cpu_domains, i).sd;
|
|
|
|
SD_INIT(sd, SIBLING);
|
|
|
|
set_domain_attribute(sd, attr);
|
|
|
|
cpumask_and(sched_domain_span(sd), cpu_map, topology_thread_cpumask(i));
|
|
|
|
sd->parent = parent;
|
|
|
|
parent->child = sd;
|
|
|
|
cpu_to_cpu_group(i, cpu_map, &sd->groups, d->tmpmask);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2009-08-18 17:57:03 +07:00
|
|
|
return sd;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-08-18 17:57:51 +07:00
|
|
|
static void build_sched_groups(struct s_data *d, enum sched_domain_level l,
|
|
|
|
const struct cpumask *cpu_map, int cpu)
|
|
|
|
{
|
|
|
|
switch (l) {
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SCHED_SMT
|
2009-08-18 17:57:51 +07:00
|
|
|
case SD_LV_SIBLING: /* set up CPU (sibling) groups */
|
|
|
|
cpumask_and(d->this_sibling_map, cpu_map,
|
|
|
|
topology_thread_cpumask(cpu));
|
|
|
|
if (cpu == cpumask_first(d->this_sibling_map))
|
|
|
|
init_sched_build_groups(d->this_sibling_map, cpu_map,
|
|
|
|
&cpu_to_cpu_group,
|
|
|
|
d->send_covered, d->tmpmask);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2006-03-27 16:15:22 +07:00
|
|
|
#ifdef CONFIG_SCHED_MC
|
2009-08-18 17:58:38 +07:00
|
|
|
case SD_LV_MC: /* set up multi-core groups */
|
|
|
|
cpumask_and(d->this_core_map, cpu_map, cpu_coregroup_mask(cpu));
|
|
|
|
if (cpu == cpumask_first(d->this_core_map))
|
|
|
|
init_sched_build_groups(d->this_core_map, cpu_map,
|
|
|
|
&cpu_to_core_group,
|
|
|
|
d->send_covered, d->tmpmask);
|
|
|
|
break;
|
2006-03-27 16:15:22 +07:00
|
|
|
#endif
|
2009-08-18 17:59:28 +07:00
|
|
|
case SD_LV_CPU: /* set up physical groups */
|
|
|
|
cpumask_and(d->nodemask, cpumask_of_node(cpu), cpu_map);
|
|
|
|
if (!cpumask_empty(d->nodemask))
|
|
|
|
init_sched_build_groups(d->nodemask, cpu_map,
|
|
|
|
&cpu_to_phys_group,
|
|
|
|
d->send_covered, d->tmpmask);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2009-08-18 18:00:13 +07:00
|
|
|
case SD_LV_ALLNODES:
|
|
|
|
init_sched_build_groups(cpu_map, cpu_map, &cpu_to_allnodes_group,
|
|
|
|
d->send_covered, d->tmpmask);
|
|
|
|
break;
|
|
|
|
#endif
|
2009-08-18 17:57:51 +07:00
|
|
|
default:
|
|
|
|
break;
|
2008-04-05 08:11:11 +07:00
|
|
|
}
|
2009-08-18 17:57:51 +07:00
|
|
|
}
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2009-08-18 17:53:00 +07:00
|
|
|
/*
|
|
|
|
* Build sched domains for a given set of cpus and attach the sched domains
|
|
|
|
* to the individual cpus
|
|
|
|
*/
|
|
|
|
static int __build_sched_domains(const struct cpumask *cpu_map,
|
|
|
|
struct sched_domain_attr *attr)
|
|
|
|
{
|
|
|
|
enum s_alloc alloc_state = sa_none;
|
|
|
|
struct s_data d;
|
2009-08-18 18:02:29 +07:00
|
|
|
struct sched_domain *sd;
|
2009-08-18 17:53:00 +07:00
|
|
|
int i;
|
2008-04-05 08:11:11 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2009-08-18 17:53:00 +07:00
|
|
|
d.sd_allnodes = 0;
|
2008-04-05 08:11:11 +07:00
|
|
|
#endif
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2009-08-18 17:53:00 +07:00
|
|
|
alloc_state = __visit_domain_allocation_hell(&d, cpu_map);
|
|
|
|
if (alloc_state != sa_rootdomain)
|
|
|
|
goto error;
|
|
|
|
alloc_state = sa_sched_groups;
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2005-06-26 04:57:33 +07:00
|
|
|
* Set up domains for cpus specified by the cpu_map.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map) {
|
2009-08-18 17:51:52 +07:00
|
|
|
cpumask_and(d.nodemask, cpumask_of_node(cpu_to_node(i)),
|
|
|
|
cpu_map);
|
2007-07-09 23:52:00 +07:00
|
|
|
|
2009-08-18 17:54:06 +07:00
|
|
|
sd = __build_numa_sched_domains(&d, cpu_map, attr, i);
|
2009-08-18 17:54:55 +07:00
|
|
|
sd = __build_cpu_sched_domain(&d, cpu_map, attr, sd, i);
|
2009-08-18 17:56:14 +07:00
|
|
|
sd = __build_mc_sched_domain(&d, cpu_map, attr, sd, i);
|
2009-08-18 17:57:03 +07:00
|
|
|
sd = __build_smt_sched_domain(&d, cpu_map, attr, sd, i);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map) {
|
2009-08-18 17:57:51 +07:00
|
|
|
build_sched_groups(&d, SD_LV_SIBLING, cpu_map, i);
|
2009-08-18 17:58:38 +07:00
|
|
|
build_sched_groups(&d, SD_LV_MC, cpu_map, i);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Set up physical groups */
|
2009-08-18 17:59:28 +07:00
|
|
|
for (i = 0; i < nr_node_ids; i++)
|
|
|
|
build_sched_groups(&d, SD_LV_CPU, cpu_map, i);
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
/* Set up node groups */
|
2009-08-18 18:00:13 +07:00
|
|
|
if (d.sd_allnodes)
|
|
|
|
build_sched_groups(&d, SD_LV_ALLNODES, cpu_map, 0);
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2009-08-18 18:01:11 +07:00
|
|
|
for (i = 0; i < nr_node_ids; i++)
|
|
|
|
if (build_numa_sched_groups(&d, cpu_map, i))
|
2006-06-27 16:54:38 +07:00
|
|
|
goto error;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Calculate CPU power for physical packages and nodes */
|
2006-06-27 16:54:42 +07:00
|
|
|
#ifdef CONFIG_SCHED_SMT
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map) {
|
2009-08-18 18:02:29 +07:00
|
|
|
sd = &per_cpu(cpu_domains, i).sd;
|
2006-10-03 15:14:09 +07:00
|
|
|
init_sched_groups_power(i, sd);
|
2006-06-27 16:54:42 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2006-03-27 16:15:22 +07:00
|
|
|
#ifdef CONFIG_SCHED_MC
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map) {
|
2009-08-18 18:02:29 +07:00
|
|
|
sd = &per_cpu(core_domains, i).sd;
|
2006-10-03 15:14:09 +07:00
|
|
|
init_sched_groups_power(i, sd);
|
2006-06-27 16:54:42 +07:00
|
|
|
}
|
|
|
|
#endif
|
2006-03-27 16:15:22 +07:00
|
|
|
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map) {
|
2009-08-18 18:02:29 +07:00
|
|
|
sd = &per_cpu(phys_domains, i).sd;
|
2006-10-03 15:14:09 +07:00
|
|
|
init_sched_groups_power(i, sd);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-09-07 05:18:14 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2008-05-13 02:21:12 +07:00
|
|
|
for (i = 0; i < nr_node_ids; i++)
|
2009-08-18 17:51:52 +07:00
|
|
|
init_numa_sched_groups_power(d.sched_group_nodes[i]);
|
2005-09-07 05:18:14 +07:00
|
|
|
|
2009-08-18 17:51:52 +07:00
|
|
|
if (d.sd_allnodes) {
|
2006-12-10 17:20:07 +07:00
|
|
|
struct sched_group *sg;
|
2006-07-30 17:02:59 +07:00
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
cpu_to_allnodes_group(cpumask_first(cpu_map), cpu_map, &sg,
|
2009-08-18 17:51:52 +07:00
|
|
|
d.tmpmask);
|
2006-07-30 17:02:59 +07:00
|
|
|
init_numa_sched_groups_power(sg);
|
|
|
|
}
|
2005-09-07 05:18:14 +07:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Attach the domains */
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map) {
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SCHED_SMT
|
2008-11-24 23:05:04 +07:00
|
|
|
sd = &per_cpu(cpu_domains, i).sd;
|
2006-03-27 16:15:22 +07:00
|
|
|
#elif defined(CONFIG_SCHED_MC)
|
2008-11-24 23:05:04 +07:00
|
|
|
sd = &per_cpu(core_domains, i).sd;
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
2008-11-24 23:05:04 +07:00
|
|
|
sd = &per_cpu(phys_domains, i).sd;
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2009-08-18 17:51:52 +07:00
|
|
|
cpu_attach_domain(sd, d.rd, i);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-06-27 16:54:38 +07:00
|
|
|
|
2009-08-18 17:53:00 +07:00
|
|
|
d.sched_group_nodes = NULL; /* don't free this we still need it */
|
|
|
|
__free_domain_allocs(&d, sa_tmpmask, cpu_map);
|
|
|
|
return 0;
|
2006-06-27 16:54:38 +07:00
|
|
|
|
|
|
|
error:
|
2009-08-18 17:53:00 +07:00
|
|
|
__free_domain_allocs(&d, alloc_state, cpu_map);
|
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-10-19 13:40:20 +07:00
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
static int build_sched_domains(const struct cpumask *cpu_map)
|
2008-04-15 12:04:23 +07:00
|
|
|
{
|
|
|
|
return __build_sched_domains(cpu_map, NULL);
|
|
|
|
}
|
|
|
|
|
2009-11-03 11:23:40 +07:00
|
|
|
static cpumask_var_t *doms_cur; /* current sched domains */
|
2007-10-19 13:40:20 +07:00
|
|
|
static int ndoms_cur; /* number of sched domains in 'doms_cur' */
|
2008-05-16 22:47:14 +07:00
|
|
|
static struct sched_domain_attr *dattr_cur;
|
|
|
|
/* attribues of custom domains in 'doms_cur' */
|
2007-10-19 13:40:20 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Special case: If a kmalloc of a doms_cur partition (array of
|
2008-11-24 23:05:12 +07:00
|
|
|
* cpumask) fails, then fallback to a single sched domain,
|
|
|
|
* as determined by the single cpumask fallback_doms.
|
2007-10-19 13:40:20 +07:00
|
|
|
*/
|
2008-11-24 23:05:12 +07:00
|
|
|
static cpumask_var_t fallback_doms;
|
2007-10-19 13:40:20 +07:00
|
|
|
|
2008-12-10 00:49:50 +07:00
|
|
|
/*
|
|
|
|
* arch_update_cpu_topology lets virtualized architectures update the
|
|
|
|
* cpu core maps. It is supposed to return 1 if the topology changed
|
|
|
|
* or 0 if it stayed the same.
|
|
|
|
*/
|
|
|
|
int __attribute__((weak)) arch_update_cpu_topology(void)
|
2008-03-13 00:31:59 +07:00
|
|
|
{
|
2008-12-10 00:49:50 +07:00
|
|
|
return 0;
|
2008-03-13 00:31:59 +07:00
|
|
|
}
|
|
|
|
|
2009-11-03 11:23:40 +07:00
|
|
|
cpumask_var_t *alloc_sched_domains(unsigned int ndoms)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
cpumask_var_t *doms;
|
|
|
|
|
|
|
|
doms = kmalloc(sizeof(*doms) * ndoms, GFP_KERNEL);
|
|
|
|
if (!doms)
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; i < ndoms; i++) {
|
|
|
|
if (!alloc_cpumask_var(&doms[i], GFP_KERNEL)) {
|
|
|
|
free_sched_domains(doms, i);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return doms;
|
|
|
|
}
|
|
|
|
|
|
|
|
void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ndoms; i++)
|
|
|
|
free_cpumask_var(doms[i]);
|
|
|
|
kfree(doms);
|
|
|
|
}
|
|
|
|
|
2005-06-26 04:57:33 +07:00
|
|
|
/*
|
2007-12-05 21:46:09 +07:00
|
|
|
* Set up scheduler domains and groups. Callers must hold the hotplug lock.
|
2007-10-19 13:40:20 +07:00
|
|
|
* For now this just excludes isolated cpus, but could be used to
|
|
|
|
* exclude other special cases in the future.
|
2005-06-26 04:57:33 +07:00
|
|
|
*/
|
2008-11-24 23:05:14 +07:00
|
|
|
static int arch_init_sched_domains(const struct cpumask *cpu_map)
|
2005-06-26 04:57:33 +07:00
|
|
|
{
|
2007-10-24 23:23:48 +07:00
|
|
|
int err;
|
|
|
|
|
2008-03-13 00:31:59 +07:00
|
|
|
arch_update_cpu_topology();
|
2007-10-19 13:40:20 +07:00
|
|
|
ndoms_cur = 1;
|
2009-11-03 11:23:40 +07:00
|
|
|
doms_cur = alloc_sched_domains(ndoms_cur);
|
2007-10-19 13:40:20 +07:00
|
|
|
if (!doms_cur)
|
2009-11-03 11:23:40 +07:00
|
|
|
doms_cur = &fallback_doms;
|
|
|
|
cpumask_andnot(doms_cur[0], cpu_map, cpu_isolated_map);
|
2008-04-15 12:04:23 +07:00
|
|
|
dattr_cur = NULL;
|
2009-11-03 11:23:40 +07:00
|
|
|
err = build_sched_domains(doms_cur[0]);
|
2007-10-15 22:00:19 +07:00
|
|
|
register_sched_domain_sysctl();
|
2007-10-24 23:23:48 +07:00
|
|
|
|
|
|
|
return err;
|
2005-06-26 04:57:33 +07:00
|
|
|
}
|
|
|
|
|
2008-11-24 23:05:14 +07:00
|
|
|
static void arch_destroy_sched_domains(const struct cpumask *cpu_map,
|
|
|
|
struct cpumask *tmpmask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-04-05 08:11:11 +07:00
|
|
|
free_sched_groups(cpu_map, tmpmask);
|
2005-09-07 05:18:14 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-26 04:57:33 +07:00
|
|
|
/*
|
|
|
|
* Detach sched domains from a group of cpus specified in cpu_map
|
|
|
|
* These cpus will now be attached to the NULL domain
|
|
|
|
*/
|
2008-11-24 23:05:14 +07:00
|
|
|
static void detach_destroy_domains(const struct cpumask *cpu_map)
|
2005-06-26 04:57:33 +07:00
|
|
|
{
|
2008-11-24 23:05:14 +07:00
|
|
|
/* Save because hotplug lock held. */
|
|
|
|
static DECLARE_BITMAP(tmpmask, CONFIG_NR_CPUS);
|
2005-06-26 04:57:33 +07:00
|
|
|
int i;
|
|
|
|
|
2008-11-24 23:05:02 +07:00
|
|
|
for_each_cpu(i, cpu_map)
|
2008-01-26 03:08:18 +07:00
|
|
|
cpu_attach_domain(NULL, &def_root_domain, i);
|
2005-06-26 04:57:33 +07:00
|
|
|
synchronize_sched();
|
2008-11-24 23:05:14 +07:00
|
|
|
arch_destroy_sched_domains(cpu_map, to_cpumask(tmpmask));
|
2005-06-26 04:57:33 +07:00
|
|
|
}
|
|
|
|
|
2008-04-15 12:04:23 +07:00
|
|
|
/* handle null as "default" */
|
|
|
|
static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
|
|
|
|
struct sched_domain_attr *new, int idx_new)
|
|
|
|
{
|
|
|
|
struct sched_domain_attr tmp;
|
|
|
|
|
|
|
|
/* fast path */
|
|
|
|
if (!new && !cur)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
tmp = SD_ATTR_INIT;
|
|
|
|
return !memcmp(cur ? (cur + idx_cur) : &tmp,
|
|
|
|
new ? (new + idx_new) : &tmp,
|
|
|
|
sizeof(struct sched_domain_attr));
|
|
|
|
}
|
|
|
|
|
2007-10-19 13:40:20 +07:00
|
|
|
/*
|
|
|
|
* Partition sched domains as specified by the 'ndoms_new'
|
2007-12-05 21:46:09 +07:00
|
|
|
* cpumasks in the array doms_new[] of cpumasks. This compares
|
2007-10-19 13:40:20 +07:00
|
|
|
* doms_new[] to the current sched domain partitioning, doms_cur[].
|
|
|
|
* It destroys each deleted domain and builds each new domain.
|
|
|
|
*
|
2009-11-03 11:23:40 +07:00
|
|
|
* 'doms_new' is an array of cpumask_var_t's of length 'ndoms_new'.
|
2007-12-05 21:46:09 +07:00
|
|
|
* The masks don't intersect (don't overlap.) We should setup one
|
|
|
|
* sched domain for each mask. CPUs not in any of the cpumasks will
|
|
|
|
* not be load balanced. If the same cpumask appears both in the
|
2007-10-19 13:40:20 +07:00
|
|
|
* current 'doms_cur' domains and in the new 'doms_new', we can leave
|
|
|
|
* it as it is.
|
|
|
|
*
|
2009-11-03 11:23:40 +07:00
|
|
|
* The passed in 'doms_new' should be allocated using
|
|
|
|
* alloc_sched_domains. This routine takes ownership of it and will
|
|
|
|
* free_sched_domains it when done with it. If the caller failed the
|
|
|
|
* alloc call, then it can pass in doms_new == NULL && ndoms_new == 1,
|
|
|
|
* and partition_sched_domains() will fallback to the single partition
|
|
|
|
* 'fallback_doms', it also forces the domains to be rebuilt.
|
2007-10-19 13:40:20 +07:00
|
|
|
*
|
2008-11-24 23:05:14 +07:00
|
|
|
* If doms_new == NULL it will be replaced with cpu_online_mask.
|
2008-11-18 13:02:03 +07:00
|
|
|
* ndoms_new == 0 is a special case for destroying existing domains,
|
|
|
|
* and it will not create the default domain.
|
2008-08-30 03:11:41 +07:00
|
|
|
*
|
2007-10-19 13:40:20 +07:00
|
|
|
* Call with hotplug lock held
|
|
|
|
*/
|
2009-11-03 11:23:40 +07:00
|
|
|
void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
|
2008-04-15 12:04:23 +07:00
|
|
|
struct sched_domain_attr *dattr_new)
|
2007-10-19 13:40:20 +07:00
|
|
|
{
|
2008-08-30 03:11:41 +07:00
|
|
|
int i, j, n;
|
2008-12-10 00:49:51 +07:00
|
|
|
int new_topology;
|
2007-10-19 13:40:20 +07:00
|
|
|
|
2008-04-28 16:33:07 +07:00
|
|
|
mutex_lock(&sched_domains_mutex);
|
2008-01-26 03:08:00 +07:00
|
|
|
|
2007-10-24 23:23:48 +07:00
|
|
|
/* always unregister in case we don't destroy any domains */
|
|
|
|
unregister_sched_domain_sysctl();
|
|
|
|
|
2008-12-10 00:49:51 +07:00
|
|
|
/* Let architecture update cpu core mappings. */
|
|
|
|
new_topology = arch_update_cpu_topology();
|
|
|
|
|
2008-08-30 03:11:41 +07:00
|
|
|
n = doms_new ? ndoms_new : 0;
|
2007-10-19 13:40:20 +07:00
|
|
|
|
|
|
|
/* Destroy deleted domains */
|
|
|
|
for (i = 0; i < ndoms_cur; i++) {
|
2008-12-10 00:49:51 +07:00
|
|
|
for (j = 0; j < n && !new_topology; j++) {
|
2009-11-03 11:23:40 +07:00
|
|
|
if (cpumask_equal(doms_cur[i], doms_new[j])
|
2008-04-15 12:04:23 +07:00
|
|
|
&& dattrs_equal(dattr_cur, i, dattr_new, j))
|
2007-10-19 13:40:20 +07:00
|
|
|
goto match1;
|
|
|
|
}
|
|
|
|
/* no match - a current sched domain not in new doms_new[] */
|
2009-11-03 11:23:40 +07:00
|
|
|
detach_destroy_domains(doms_cur[i]);
|
2007-10-19 13:40:20 +07:00
|
|
|
match1:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2008-07-15 18:43:49 +07:00
|
|
|
if (doms_new == NULL) {
|
|
|
|
ndoms_cur = 0;
|
2009-11-03 11:23:40 +07:00
|
|
|
doms_new = &fallback_doms;
|
2009-11-25 19:31:39 +07:00
|
|
|
cpumask_andnot(doms_new[0], cpu_active_mask, cpu_isolated_map);
|
2008-11-04 15:20:23 +07:00
|
|
|
WARN_ON_ONCE(dattr_new);
|
2008-07-15 18:43:49 +07:00
|
|
|
}
|
|
|
|
|
2007-10-19 13:40:20 +07:00
|
|
|
/* Build new domains */
|
|
|
|
for (i = 0; i < ndoms_new; i++) {
|
2008-12-10 00:49:51 +07:00
|
|
|
for (j = 0; j < ndoms_cur && !new_topology; j++) {
|
2009-11-03 11:23:40 +07:00
|
|
|
if (cpumask_equal(doms_new[i], doms_cur[j])
|
2008-04-15 12:04:23 +07:00
|
|
|
&& dattrs_equal(dattr_new, i, dattr_cur, j))
|
2007-10-19 13:40:20 +07:00
|
|
|
goto match2;
|
|
|
|
}
|
|
|
|
/* no match - add a new doms_new */
|
2009-11-03 11:23:40 +07:00
|
|
|
__build_sched_domains(doms_new[i],
|
2008-04-15 12:04:23 +07:00
|
|
|
dattr_new ? dattr_new + i : NULL);
|
2007-10-19 13:40:20 +07:00
|
|
|
match2:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remember the new sched domains */
|
2009-11-03 11:23:40 +07:00
|
|
|
if (doms_cur != &fallback_doms)
|
|
|
|
free_sched_domains(doms_cur, ndoms_cur);
|
2008-04-15 12:04:23 +07:00
|
|
|
kfree(dattr_cur); /* kfree(NULL) is safe */
|
2007-10-19 13:40:20 +07:00
|
|
|
doms_cur = doms_new;
|
2008-04-15 12:04:23 +07:00
|
|
|
dattr_cur = dattr_new;
|
2007-10-19 13:40:20 +07:00
|
|
|
ndoms_cur = ndoms_new;
|
2007-10-24 23:23:48 +07:00
|
|
|
|
|
|
|
register_sched_domain_sysctl();
|
2008-01-26 03:08:00 +07:00
|
|
|
|
2008-04-28 16:33:07 +07:00
|
|
|
mutex_unlock(&sched_domains_mutex);
|
2007-10-19 13:40:20 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 16:54:42 +07:00
|
|
|
#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
|
2009-01-05 18:07:50 +07:00
|
|
|
static void arch_reinit_sched_domains(void)
|
2006-06-27 16:54:42 +07:00
|
|
|
{
|
2008-01-26 03:08:02 +07:00
|
|
|
get_online_cpus();
|
2008-08-30 03:11:41 +07:00
|
|
|
|
|
|
|
/* Destroy domains first to force the rebuild */
|
|
|
|
partition_sched_domains(0, NULL, NULL);
|
|
|
|
|
2008-07-15 18:43:49 +07:00
|
|
|
rebuild_sched_domains();
|
2008-01-26 03:08:02 +07:00
|
|
|
put_online_cpus();
|
2006-06-27 16:54:42 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t sched_power_savings_store(const char *buf, size_t count, int smt)
|
|
|
|
{
|
2008-12-19 00:56:09 +07:00
|
|
|
unsigned int level = 0;
|
2006-06-27 16:54:42 +07:00
|
|
|
|
2008-12-19 00:56:09 +07:00
|
|
|
if (sscanf(buf, "%u", &level) != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* level is always be positive so don't check for
|
|
|
|
* level < POWERSAVINGS_BALANCE_NONE which is 0
|
|
|
|
* What happens on 0 or 1 byte write,
|
|
|
|
* need to check for count as well?
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (level >= MAX_POWERSAVINGS_BALANCE_LEVELS)
|
2006-06-27 16:54:42 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (smt)
|
2008-12-19 00:56:09 +07:00
|
|
|
sched_smt_power_savings = level;
|
2006-06-27 16:54:42 +07:00
|
|
|
else
|
2008-12-19 00:56:09 +07:00
|
|
|
sched_mc_power_savings = level;
|
2006-06-27 16:54:42 +07:00
|
|
|
|
2009-01-05 18:07:50 +07:00
|
|
|
arch_reinit_sched_domains();
|
2006-06-27 16:54:42 +07:00
|
|
|
|
2009-01-05 18:07:50 +07:00
|
|
|
return count;
|
2006-06-27 16:54:42 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_MC
|
2008-07-30 12:33:52 +07:00
|
|
|
static ssize_t sched_mc_power_savings_show(struct sysdev_class *class,
|
2010-01-05 18:47:58 +07:00
|
|
|
struct sysdev_class_attribute *attr,
|
2008-07-30 12:33:52 +07:00
|
|
|
char *page)
|
2006-06-27 16:54:42 +07:00
|
|
|
{
|
|
|
|
return sprintf(page, "%u\n", sched_mc_power_savings);
|
|
|
|
}
|
2008-07-30 12:33:52 +07:00
|
|
|
static ssize_t sched_mc_power_savings_store(struct sysdev_class *class,
|
2010-01-05 18:47:58 +07:00
|
|
|
struct sysdev_class_attribute *attr,
|
2006-07-03 14:25:40 +07:00
|
|
|
const char *buf, size_t count)
|
2006-06-27 16:54:42 +07:00
|
|
|
{
|
|
|
|
return sched_power_savings_store(buf, count, 0);
|
|
|
|
}
|
2008-07-30 12:33:52 +07:00
|
|
|
static SYSDEV_CLASS_ATTR(sched_mc_power_savings, 0644,
|
|
|
|
sched_mc_power_savings_show,
|
|
|
|
sched_mc_power_savings_store);
|
2006-06-27 16:54:42 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_SMT
|
2008-07-30 12:33:52 +07:00
|
|
|
static ssize_t sched_smt_power_savings_show(struct sysdev_class *dev,
|
2010-01-05 18:47:58 +07:00
|
|
|
struct sysdev_class_attribute *attr,
|
2008-07-30 12:33:52 +07:00
|
|
|
char *page)
|
2006-06-27 16:54:42 +07:00
|
|
|
{
|
|
|
|
return sprintf(page, "%u\n", sched_smt_power_savings);
|
|
|
|
}
|
2008-07-30 12:33:52 +07:00
|
|
|
static ssize_t sched_smt_power_savings_store(struct sysdev_class *dev,
|
2010-01-05 18:47:58 +07:00
|
|
|
struct sysdev_class_attribute *attr,
|
2006-07-03 14:25:40 +07:00
|
|
|
const char *buf, size_t count)
|
2006-06-27 16:54:42 +07:00
|
|
|
{
|
|
|
|
return sched_power_savings_store(buf, count, 1);
|
|
|
|
}
|
2008-07-30 12:33:52 +07:00
|
|
|
static SYSDEV_CLASS_ATTR(sched_smt_power_savings, 0644,
|
|
|
|
sched_smt_power_savings_show,
|
2007-08-12 23:08:19 +07:00
|
|
|
sched_smt_power_savings_store);
|
|
|
|
#endif
|
|
|
|
|
2009-01-05 18:18:02 +07:00
|
|
|
int __init sched_create_sysfs_power_savings_entries(struct sysdev_class *cls)
|
2007-08-12 23:08:19 +07:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_SMT
|
|
|
|
if (smt_capable())
|
|
|
|
err = sysfs_create_file(&cls->kset.kobj,
|
|
|
|
&attr_sched_smt_power_savings.attr);
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SCHED_MC
|
|
|
|
if (!err && mc_capable())
|
|
|
|
err = sysfs_create_file(&cls->kset.kobj,
|
|
|
|
&attr_sched_mc_power_savings.attr);
|
|
|
|
#endif
|
|
|
|
return err;
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
|
2006-06-27 16:54:42 +07:00
|
|
|
|
2008-07-15 18:43:49 +07:00
|
|
|
#ifndef CONFIG_CPUSETS
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2008-07-15 18:43:49 +07:00
|
|
|
* Add online and remove offline CPUs from the scheduler domains.
|
|
|
|
* When cpusets are enabled they take over this function.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
static int update_sched_domains(struct notifier_block *nfb,
|
|
|
|
unsigned long action, void *hcpu)
|
2008-07-15 18:43:49 +07:00
|
|
|
{
|
|
|
|
switch (action) {
|
|
|
|
case CPU_ONLINE:
|
|
|
|
case CPU_ONLINE_FROZEN:
|
2009-11-25 19:31:39 +07:00
|
|
|
case CPU_DOWN_PREPARE:
|
|
|
|
case CPU_DOWN_PREPARE_FROZEN:
|
|
|
|
case CPU_DOWN_FAILED:
|
|
|
|
case CPU_DOWN_FAILED_FROZEN:
|
2008-08-30 03:11:41 +07:00
|
|
|
partition_sched_domains(1, NULL, NULL);
|
2008-07-15 18:43:49 +07:00
|
|
|
return NOTIFY_OK;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int update_runtime(struct notifier_block *nfb,
|
|
|
|
unsigned long action, void *hcpu)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-06-05 19:49:58 +07:00
|
|
|
int cpu = (int)(long)hcpu;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
switch (action) {
|
|
|
|
case CPU_DOWN_PREPARE:
|
2007-05-09 16:35:10 +07:00
|
|
|
case CPU_DOWN_PREPARE_FROZEN:
|
2008-06-05 19:49:58 +07:00
|
|
|
disable_runtime(cpu_rq(cpu));
|
2005-04-17 05:20:36 +07:00
|
|
|
return NOTIFY_OK;
|
|
|
|
|
|
|
|
case CPU_DOWN_FAILED:
|
2007-05-09 16:35:10 +07:00
|
|
|
case CPU_DOWN_FAILED_FROZEN:
|
2005-04-17 05:20:36 +07:00
|
|
|
case CPU_ONLINE:
|
2007-05-09 16:35:10 +07:00
|
|
|
case CPU_ONLINE_FROZEN:
|
2008-06-05 19:49:58 +07:00
|
|
|
enable_runtime(cpu_rq(cpu));
|
2008-07-15 18:43:49 +07:00
|
|
|
return NOTIFY_OK;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
default:
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init sched_init_smp(void)
|
|
|
|
{
|
2008-11-24 23:05:12 +07:00
|
|
|
cpumask_var_t non_isolated_cpus;
|
|
|
|
|
|
|
|
alloc_cpumask_var(&non_isolated_cpus, GFP_KERNEL);
|
2009-09-14 19:20:16 +07:00
|
|
|
alloc_cpumask_var(&fallback_doms, GFP_KERNEL);
|
2006-10-03 15:14:04 +07:00
|
|
|
|
2008-04-05 08:11:04 +07:00
|
|
|
#if defined(CONFIG_NUMA)
|
|
|
|
sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
|
|
|
|
GFP_KERNEL);
|
|
|
|
BUG_ON(sched_group_nodes_bycpu == NULL);
|
|
|
|
#endif
|
2008-01-26 03:08:02 +07:00
|
|
|
get_online_cpus();
|
2008-04-28 16:33:07 +07:00
|
|
|
mutex_lock(&sched_domains_mutex);
|
2009-11-25 19:31:39 +07:00
|
|
|
arch_init_sched_domains(cpu_active_mask);
|
2008-11-24 23:05:12 +07:00
|
|
|
cpumask_andnot(non_isolated_cpus, cpu_possible_mask, cpu_isolated_map);
|
|
|
|
if (cpumask_empty(non_isolated_cpus))
|
|
|
|
cpumask_set_cpu(smp_processor_id(), non_isolated_cpus);
|
2008-04-28 16:33:07 +07:00
|
|
|
mutex_unlock(&sched_domains_mutex);
|
2008-01-26 03:08:02 +07:00
|
|
|
put_online_cpus();
|
2008-07-15 18:43:49 +07:00
|
|
|
|
|
|
|
#ifndef CONFIG_CPUSETS
|
2005-04-17 05:20:36 +07:00
|
|
|
/* XXX: Theoretical race here - CPU may be hotplugged now */
|
|
|
|
hotcpu_notifier(update_sched_domains, 0);
|
2008-07-15 18:43:49 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* RT runtime code needs to handle some hotplug events */
|
|
|
|
hotcpu_notifier(update_runtime, 0);
|
|
|
|
|
2008-04-29 15:02:46 +07:00
|
|
|
init_hrtick();
|
2006-10-03 15:14:04 +07:00
|
|
|
|
|
|
|
/* Move init over to a non-isolated CPU */
|
2008-11-24 23:05:12 +07:00
|
|
|
if (set_cpus_allowed_ptr(current, non_isolated_cpus) < 0)
|
2006-10-03 15:14:04 +07:00
|
|
|
BUG();
|
2007-11-10 04:39:38 +07:00
|
|
|
sched_init_granularity();
|
2008-11-24 23:05:12 +07:00
|
|
|
free_cpumask_var(non_isolated_cpus);
|
2008-11-24 23:05:12 +07:00
|
|
|
|
2008-11-24 23:05:13 +07:00
|
|
|
init_sched_rt_class();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
void __init sched_init_smp(void)
|
|
|
|
{
|
2007-11-10 04:39:38 +07:00
|
|
|
sched_init_granularity();
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2009-04-16 13:45:34 +07:00
|
|
|
const_debug unsigned int sysctl_timer_migration = 1;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
int in_sched_functions(unsigned long addr)
|
|
|
|
{
|
|
|
|
return in_lock_functions(addr) ||
|
|
|
|
(addr >= (unsigned long)__sched_text_start
|
|
|
|
&& addr < (unsigned long)__sched_text_end);
|
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:13 +07:00
|
|
|
static void init_cfs_rq(struct cfs_rq *cfs_rq, struct rq *rq)
|
2007-07-09 23:51:59 +07:00
|
|
|
{
|
|
|
|
cfs_rq->tasks_timeline = RB_ROOT;
|
2008-04-20 00:45:00 +07:00
|
|
|
INIT_LIST_HEAD(&cfs_rq->tasks);
|
2007-07-09 23:51:59 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
cfs_rq->rq = rq;
|
|
|
|
#endif
|
2007-10-15 22:00:10 +07:00
|
|
|
cfs_rq->min_vruntime = (u64)(-(1LL << 20));
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:29 +07:00
|
|
|
static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
|
|
|
|
{
|
|
|
|
struct rt_prio_array *array;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
array = &rt_rq->active;
|
|
|
|
for (i = 0; i < MAX_RT_PRIO; i++) {
|
|
|
|
INIT_LIST_HEAD(array->queue + i);
|
|
|
|
__clear_bit(i, array->bitmap);
|
|
|
|
}
|
|
|
|
/* delimiter for bitsearch: */
|
|
|
|
__set_bit(MAX_RT_PRIO, array->bitmap);
|
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
|
2008-12-29 21:39:49 +07:00
|
|
|
rt_rq->highest_prio.curr = MAX_RT_PRIO;
|
2009-01-14 21:10:04 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2008-12-29 21:39:49 +07:00
|
|
|
rt_rq->highest_prio.next = MAX_RT_PRIO;
|
2008-01-26 03:08:31 +07:00
|
|
|
#endif
|
|
|
|
#endif
|
2008-01-26 03:08:29 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
rt_rq->rt_nr_migratory = 0;
|
|
|
|
rt_rq->overloaded = 0;
|
2009-11-17 20:28:38 +07:00
|
|
|
plist_head_init_raw(&rt_rq->pushable_tasks, &rq->lock);
|
2008-01-26 03:08:29 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
rt_rq->rt_time = 0;
|
|
|
|
rt_rq->rt_throttled = 0;
|
2008-04-20 00:44:58 +07:00
|
|
|
rt_rq->rt_runtime = 0;
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock_init(&rt_rq->rt_runtime_lock);
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-02-13 21:45:39 +07:00
|
|
|
rt_rq->rt_nr_boosted = 0;
|
2008-01-26 03:08:30 +07:00
|
|
|
rt_rq->rq = rq;
|
|
|
|
#endif
|
2008-01-26 03:08:29 +07:00
|
|
|
}
|
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2008-04-20 00:44:59 +07:00
|
|
|
static void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
|
|
|
|
struct sched_entity *se, int cpu, int add,
|
|
|
|
struct sched_entity *parent)
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
2008-04-20 00:44:59 +07:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
2008-01-26 03:08:30 +07:00
|
|
|
tg->cfs_rq[cpu] = cfs_rq;
|
|
|
|
init_cfs_rq(cfs_rq, rq);
|
|
|
|
cfs_rq->tg = tg;
|
|
|
|
if (add)
|
|
|
|
list_add(&cfs_rq->leaf_cfs_rq_list, &rq->leaf_cfs_rq_list);
|
|
|
|
|
|
|
|
tg->se[cpu] = se;
|
2008-04-20 00:44:59 +07:00
|
|
|
/* se could be NULL for init_task_group */
|
|
|
|
if (!se)
|
|
|
|
return;
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
if (!parent)
|
|
|
|
se->cfs_rq = &rq->cfs;
|
|
|
|
else
|
|
|
|
se->cfs_rq = parent->my_q;
|
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
se->my_q = cfs_rq;
|
|
|
|
se->load.weight = tg->shares;
|
2008-05-06 04:56:17 +07:00
|
|
|
se->load.inv_weight = 0;
|
2008-04-20 00:44:59 +07:00
|
|
|
se->parent = parent;
|
2008-01-26 03:08:30 +07:00
|
|
|
}
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-04-20 00:44:59 +07:00
|
|
|
static void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
|
|
|
|
struct sched_rt_entity *rt_se, int cpu, int add,
|
|
|
|
struct sched_rt_entity *parent)
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
2008-04-20 00:44:59 +07:00
|
|
|
struct rq *rq = cpu_rq(cpu);
|
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
tg->rt_rq[cpu] = rt_rq;
|
|
|
|
init_rt_rq(rt_rq, rq);
|
|
|
|
rt_rq->tg = tg;
|
2008-04-20 00:44:58 +07:00
|
|
|
rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
|
2008-01-26 03:08:30 +07:00
|
|
|
if (add)
|
|
|
|
list_add(&rt_rq->leaf_rt_rq_list, &rq->leaf_rt_rq_list);
|
|
|
|
|
|
|
|
tg->rt_se[cpu] = rt_se;
|
2008-04-20 00:44:59 +07:00
|
|
|
if (!rt_se)
|
|
|
|
return;
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
if (!parent)
|
|
|
|
rt_se->rt_rq = &rq->rt;
|
|
|
|
else
|
|
|
|
rt_se->rt_rq = parent->my_q;
|
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
rt_se->my_q = rt_rq;
|
2008-04-20 00:44:59 +07:00
|
|
|
rt_se->parent = parent;
|
2008-01-26 03:08:30 +07:00
|
|
|
INIT_LIST_HEAD(&rt_se->run_list);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
void __init sched_init(void)
|
|
|
|
{
|
2007-07-09 23:51:59 +07:00
|
|
|
int i, j;
|
2008-04-05 08:11:04 +07:00
|
|
|
unsigned long alloc_size = 0, ptr;
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
alloc_size += 2 * nr_cpu_ids * sizeof(void **);
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
alloc_size += 2 * nr_cpu_ids * sizeof(void **);
|
2008-04-20 00:45:00 +07:00
|
|
|
#endif
|
2009-03-19 11:52:20 +07:00
|
|
|
#ifdef CONFIG_CPUMASK_OFFSTACK
|
2009-03-19 11:52:20 +07:00
|
|
|
alloc_size += num_possible_cpus() * cpumask_size();
|
2008-04-05 08:11:04 +07:00
|
|
|
#endif
|
|
|
|
if (alloc_size) {
|
2009-06-11 03:42:36 +07:00
|
|
|
ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
|
2008-04-05 08:11:04 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
init_task_group.se = (struct sched_entity **)ptr;
|
|
|
|
ptr += nr_cpu_ids * sizeof(void **);
|
|
|
|
|
|
|
|
init_task_group.cfs_rq = (struct cfs_rq **)ptr;
|
|
|
|
ptr += nr_cpu_ids * sizeof(void **);
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
2008-04-05 08:11:04 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
init_task_group.rt_se = (struct sched_rt_entity **)ptr;
|
|
|
|
ptr += nr_cpu_ids * sizeof(void **);
|
|
|
|
|
|
|
|
init_task_group.rt_rq = (struct rt_rq **)ptr;
|
2008-04-20 00:45:00 +07:00
|
|
|
ptr += nr_cpu_ids * sizeof(void **);
|
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_RT_GROUP_SCHED */
|
2009-03-19 11:52:20 +07:00
|
|
|
#ifdef CONFIG_CPUMASK_OFFSTACK
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
per_cpu(load_balance_tmpmask, i) = (void *)ptr;
|
|
|
|
ptr += cpumask_size();
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_CPUMASK_OFFSTACK */
|
2008-04-05 08:11:04 +07:00
|
|
|
}
|
2007-07-09 23:51:59 +07:00
|
|
|
|
2008-01-26 03:08:18 +07:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
init_defrootdomain();
|
|
|
|
#endif
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
init_rt_bandwidth(&def_rt_bandwidth,
|
|
|
|
global_rt_period(), global_rt_runtime());
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
init_rt_bandwidth(&init_task_group.rt_bandwidth,
|
|
|
|
global_rt_period(), global_rt_runtime());
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_RT_GROUP_SCHED */
|
2008-04-20 00:44:57 +07:00
|
|
|
|
2010-01-20 19:26:18 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
2008-01-26 03:08:30 +07:00
|
|
|
list_add(&init_task_group.list, &task_groups);
|
2008-04-20 00:45:00 +07:00
|
|
|
INIT_LIST_HEAD(&init_task_group.children);
|
|
|
|
|
2010-01-20 19:26:18 +07:00
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
2008-01-26 03:08:30 +07:00
|
|
|
|
sched: move rq_weight data array out of .percpu
Commit 34d76c41 introduced percpu array update_shares_data, size of which
being proportional to NR_CPUS. Unfortunately this blows up ia64 for large
NR_CPUS configuration, as ia64 allows only 64k for .percpu section.
Fix this by allocating this array dynamically and keep only pointer to it
percpu.
The per-cpu handling doesn't impose significant performance penalty on
potentially contented path in tg_shares_up().
...
ffffffff8104337c: 65 48 8b 14 25 20 cd mov %gs:0xcd20,%rdx
ffffffff81043383: 00 00
ffffffff81043385: 48 c7 c0 00 e1 00 00 mov $0xe100,%rax
ffffffff8104338c: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff81043393: 00
ffffffff81043394: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff8104339b: 00
ffffffff8104339c: 48 01 d0 add %rdx,%rax
ffffffff8104339f: 49 8d 94 24 08 01 00 lea 0x108(%r12),%rdx
ffffffff810433a6: 00
ffffffff810433a7: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433ac: 48 89 45 b0 mov %rax,-0x50(%rbp)
ffffffff810433b0: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433b5: 48 89 55 c0 mov %rdx,-0x40(%rbp)
...
After:
...
ffffffff8104337c: 65 8b 04 25 28 cd 00 mov %gs:0xcd28,%eax
ffffffff81043383: 00
ffffffff81043384: 48 98 cltq
ffffffff81043386: 49 8d bc 24 08 01 00 lea 0x108(%r12),%rdi
ffffffff8104338d: 00
ffffffff8104338e: 48 8b 15 d3 7f 76 00 mov 0x767fd3(%rip),%rdx # ffffffff817ab368 <update_shares_data>
ffffffff81043395: 48 8b 34 c5 00 ee 6d mov -0x7e921200(,%rax,8),%rsi
ffffffff8104339c: 81
ffffffff8104339d: 48 c7 45 a0 00 00 00 movq $0x0,-0x60(%rbp)
ffffffff810433a4: 00
ffffffff810433a5: b9 ff ff ff ff mov $0xffffffff,%ecx
ffffffff810433aa: 48 89 7d c0 mov %rdi,-0x40(%rbp)
ffffffff810433ae: 48 c7 45 a8 00 00 00 movq $0x0,-0x58(%rbp)
ffffffff810433b5: 00
ffffffff810433b6: bb 00 04 00 00 mov $0x400,%ebx
ffffffff810433bb: 48 01 f2 add %rsi,%rdx
ffffffff810433be: 48 89 55 b0 mov %rdx,-0x50(%rbp)
...
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
Acked-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Tejun Heo <tj@kernel.org>
2009-10-28 22:26:00 +07:00
|
|
|
#if defined CONFIG_FAIR_GROUP_SCHED && defined CONFIG_SMP
|
|
|
|
update_shares_data = __alloc_percpu(nr_cpu_ids * sizeof(unsigned long),
|
|
|
|
__alignof__(unsigned long));
|
|
|
|
#endif
|
2006-03-28 16:56:37 +07:00
|
|
|
for_each_possible_cpu(i) {
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
rq = cpu_rq(i);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_init(&rq->lock);
|
2005-06-26 04:57:13 +07:00
|
|
|
rq->nr_running = 0;
|
2009-04-11 15:43:41 +07:00
|
|
|
rq->calc_load_active = 0;
|
|
|
|
rq->calc_load_update = jiffies + LOAD_FREQ;
|
2007-07-09 23:51:59 +07:00
|
|
|
init_cfs_rq(&rq->cfs, rq);
|
2008-01-26 03:08:30 +07:00
|
|
|
init_rt_rq(&rq->rt, rq);
|
2007-07-09 23:51:59 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2007-10-15 22:00:14 +07:00
|
|
|
init_task_group.shares = init_task_group_load;
|
2008-01-26 03:08:30 +07:00
|
|
|
INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
|
2008-04-20 00:44:59 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
|
|
|
/*
|
|
|
|
* How much cpu bandwidth does init_task_group get?
|
|
|
|
*
|
|
|
|
* In case of task-groups formed thr' the cgroup filesystem, it
|
|
|
|
* gets 100% of the cpu resources in the system. This overall
|
|
|
|
* system cpu resource is divided among the tasks of
|
|
|
|
* init_task_group and its child task-groups in a fair manner,
|
|
|
|
* based on each entity's (task or task-group's) weight
|
|
|
|
* (se->load.weight).
|
|
|
|
*
|
|
|
|
* In other words, if init_task_group has 10 tasks of weight
|
|
|
|
* 1024) and two child groups A0 and A1 (of weight 1024 each),
|
|
|
|
* then A0's share of the cpu resource is:
|
|
|
|
*
|
2009-05-05 00:13:30 +07:00
|
|
|
* A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
|
2008-04-20 00:44:59 +07:00
|
|
|
*
|
|
|
|
* We achieve this by letting init_task_group's tasks sit
|
|
|
|
* directly in rq->cfs (i.e init_task_group->se[] = NULL).
|
|
|
|
*/
|
2008-04-20 00:44:59 +07:00
|
|
|
init_tg_cfs_entry(&init_task_group, &rq->cfs, NULL, i, 1, NULL);
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
2008-04-20 00:44:59 +07:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
|
|
|
rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-01-26 03:08:30 +07:00
|
|
|
INIT_LIST_HEAD(&rq->leaf_rt_rq_list);
|
2008-04-20 00:44:59 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
2008-04-20 00:44:59 +07:00
|
|
|
init_tg_rt_entry(&init_task_group, &rq->rt, NULL, i, 1, NULL);
|
2008-04-20 00:44:59 +07:00
|
|
|
#endif
|
2007-07-09 23:51:59 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
|
|
|
|
rq->cpu_load[j] = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2005-06-26 04:57:24 +07:00
|
|
|
rq->sd = NULL;
|
2008-01-26 03:08:18 +07:00
|
|
|
rq->rd = NULL;
|
2010-05-31 17:37:30 +07:00
|
|
|
rq->cpu_power = SCHED_LOAD_SCALE;
|
2009-07-29 22:08:47 +07:00
|
|
|
rq->post_schedule = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
rq->active_balance = 0;
|
2007-07-09 23:51:59 +07:00
|
|
|
rq->next_balance = jiffies;
|
2005-04-17 05:20:36 +07:00
|
|
|
rq->push_cpu = 0;
|
2006-09-26 13:30:51 +07:00
|
|
|
rq->cpu = i;
|
2008-06-05 02:04:05 +07:00
|
|
|
rq->online = 0;
|
2009-11-10 09:50:02 +07:00
|
|
|
rq->idle_stamp = 0;
|
|
|
|
rq->avg_idle = 2*sysctl_sched_migration_cost;
|
2008-01-26 03:08:26 +07:00
|
|
|
rq_attach_root(rq, &def_root_domain);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
2008-01-26 03:08:29 +07:00
|
|
|
init_rq_hrtick(rq);
|
2005-04-17 05:20:36 +07:00
|
|
|
atomic_set(&rq->nr_iowait, 0);
|
|
|
|
}
|
|
|
|
|
[PATCH] sched: implement smpnice
Problem:
The introduction of separate run queues per CPU has brought with it "nice"
enforcement problems that are best described by a simple example.
For the sake of argument suppose that on a single CPU machine with a
nice==19 hard spinner and a nice==0 hard spinner running that the nice==0
task gets 95% of the CPU and the nice==19 task gets 5% of the CPU. Now
suppose that there is a system with 2 CPUs and 2 nice==19 hard spinners and
2 nice==0 hard spinners running. The user of this system would be entitled
to expect that the nice==0 tasks each get 95% of a CPU and the nice==19
tasks only get 5% each. However, whether this expectation is met is pretty
much down to luck as there are four equally likely distributions of the
tasks to the CPUs that the load balancing code will consider to be balanced
with loads of 2.0 for each CPU. Two of these distributions involve one
nice==0 and one nice==19 task per CPU and in these circumstances the users
expectations will be met. The other two distributions both involve both
nice==0 tasks being on one CPU and both nice==19 being on the other CPU and
each task will get 50% of a CPU and the user's expectations will not be
met.
Solution:
The solution to this problem that is implemented in the attached patch is
to use weighted loads when determining if the system is balanced and, when
an imbalance is detected, to move an amount of weighted load between run
queues (as opposed to a number of tasks) to restore the balance. Once
again, the easiest way to explain why both of these measures are necessary
is to use a simple example. Suppose that (in a slight variation of the
above example) that we have a two CPU system with 4 nice==0 and 4 nice=19
hard spinning tasks running and that the 4 nice==0 tasks are on one CPU and
the 4 nice==19 tasks are on the other CPU. The weighted loads for the two
CPUs would be 4.0 and 0.2 respectively and the load balancing code would
move 2 tasks resulting in one CPU with a load of 2.0 and the other with
load of 2.2. If this was considered to be a big enough imbalance to
justify moving a task and that task was moved using the current
move_tasks() then it would move the highest priority task that it found and
this would result in one CPU with a load of 3.0 and the other with a load
of 1.2 which would result in the movement of a task in the opposite
direction and so on -- infinite loop. If, on the other hand, an amount of
load to be moved is calculated from the imbalance (in this case 0.1) and
move_tasks() skips tasks until it find ones whose contributions to the
weighted load are less than this amount it would move two of the nice==19
tasks resulting in a system with 2 nice==0 and 2 nice=19 on each CPU with
loads of 2.1 for each CPU.
One of the advantages of this mechanism is that on a system where all tasks
have nice==0 the load balancing calculations would be mathematically
identical to the current load balancing code.
Notes:
struct task_struct:
has a new field load_weight which (in a trade off of space for speed)
stores the contribution that this task makes to a CPU's weighted load when
it is runnable.
struct runqueue:
has a new field raw_weighted_load which is the sum of the load_weight
values for the currently runnable tasks on this run queue. This field
always needs to be updated when nr_running is updated so two new inline
functions inc_nr_running() and dec_nr_running() have been created to make
sure that this happens. This also offers a convenient way to optimize away
this part of the smpnice mechanism when CONFIG_SMP is not defined.
int try_to_wake_up():
in this function the value SCHED_LOAD_BALANCE is used to represent the load
contribution of a single task in various calculations in the code that
decides which CPU to put the waking task on. While this would be a valid
on a system where the nice values for the runnable tasks were distributed
evenly around zero it will lead to anomalous load balancing if the
distribution is skewed in either direction. To overcome this problem
SCHED_LOAD_SCALE has been replaced by the load_weight for the relevant task
or by the average load_weight per task for the queue in question (as
appropriate).
int move_tasks():
The modifications to this function were complicated by the fact that
active_load_balance() uses it to move exactly one task without checking
whether an imbalance actually exists. This precluded the simple
overloading of max_nr_move with max_load_move and necessitated the addition
of the latter as an extra argument to the function. The internal
implementation is then modified to move up to max_nr_move tasks and
max_load_move of weighted load. This slightly complicates the code where
move_tasks() is called and if ever active_load_balance() is changed to not
use move_tasks() the implementation of move_tasks() should be simplified
accordingly.
struct sched_group *find_busiest_group():
Similar to try_to_wake_up(), there are places in this function where
SCHED_LOAD_SCALE is used to represent the load contribution of a single
task and the same issues are created. A similar solution is adopted except
that it is now the average per task contribution to a group's load (as
opposed to a run queue) that is required. As this value is not directly
available from the group it is calculated on the fly as the queues in the
groups are visited when determining the busiest group.
A key change to this function is that it is no longer to scale down
*imbalance on exit as move_tasks() uses the load in its scaled form.
void set_user_nice():
has been modified to update the task's load_weight field when it's nice
value and also to ensure that its run queue's raw_weighted_load field is
updated if it was runnable.
From: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
With smpnice, sched groups with highest priority tasks can mask the imbalance
between the other sched groups with in the same domain. This patch fixes some
of the listed down scenarios by not considering the sched groups which are
lightly loaded.
a) on a simple 4-way MP system, if we have one high priority and 4 normal
priority tasks, with smpnice we would like to see the high priority task
scheduled on one cpu, two other cpus getting one normal task each and the
fourth cpu getting the remaining two normal tasks. but with current
smpnice extra normal priority task keeps jumping from one cpu to another
cpu having the normal priority task. This is because of the
busiest_has_loaded_cpus, nr_loaded_cpus logic.. We are not including the
cpu with high priority task in max_load calculations but including that in
total and avg_load calcuations.. leading to max_load < avg_load and load
balance between cpus running normal priority tasks(2 Vs 1) will always show
imbalanace as one normal priority and the extra normal priority task will
keep moving from one cpu to another cpu having normal priority task..
b) 4-way system with HT (8 logical processors). Package-P0 T0 has a
highest priority task, T1 is idle. Package-P1 Both T0 and T1 have 1 normal
priority task each.. P2 and P3 are idle. With this patch, one of the
normal priority tasks on P1 will be moved to P2 or P3..
c) With the current weighted smp nice calculations, it doesn't always make
sense to look at the highest weighted runqueue in the busy group..
Consider a load balance scenario on a DP with HT system, with Package-0
containing one high priority and one low priority, Package-1 containing one
low priority(with other thread being idle).. Package-1 thinks that it need
to take the low priority thread from Package-0. And find_busiest_queue()
returns the cpu thread with highest priority task.. And ultimately(with
help of active load balance) we move high priority task to Package-1. And
same continues with Package-0 now, moving high priority task from package-1
to package-0.. Even without the presence of active load balance, load
balance will fail to balance the above scenario.. Fix find_busiest_queue
to use "imbalance" when it is lightly loaded.
[kernel@kolivas.org: sched: store weighted load on up]
[kernel@kolivas.org: sched: add discrete weighted cpu load function]
[suresh.b.siddha@intel.com: sched: remove dead code]
Signed-off-by: Peter Williams <pwil3058@bigpond.com.au>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Con Kolivas <kernel@kolivas.org>
Cc: John Hawkes <hawkes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-27 16:54:34 +07:00
|
|
|
set_load_weight(&init_task);
|
2006-07-30 17:03:52 +07:00
|
|
|
|
2007-07-26 18:40:43 +07:00
|
|
|
#ifdef CONFIG_PREEMPT_NOTIFIERS
|
|
|
|
INIT_HLIST_HEAD(&init_task.preempt_notifiers);
|
|
|
|
#endif
|
|
|
|
|
2006-12-10 17:20:25 +07:00
|
|
|
#ifdef CONFIG_SMP
|
Remove argument from open_softirq which is always NULL
As git-grep shows, open_softirq() is always called with the last argument
being NULL
block/blk-core.c: open_softirq(BLOCK_SOFTIRQ, blk_done_softirq, NULL);
kernel/hrtimer.c: open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq, NULL);
kernel/rcuclassic.c: open_softirq(RCU_SOFTIRQ, rcu_process_callbacks, NULL);
kernel/rcupreempt.c: open_softirq(RCU_SOFTIRQ, rcu_process_callbacks, NULL);
kernel/sched.c: open_softirq(SCHED_SOFTIRQ, run_rebalance_domains, NULL);
kernel/softirq.c: open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);
kernel/softirq.c: open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);
kernel/timer.c: open_softirq(TIMER_SOFTIRQ, run_timer_softirq, NULL);
net/core/dev.c: open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
net/core/dev.c: open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
This observation has already been made by Matthew Wilcox in June 2002
(http://www.cs.helsinki.fi/linux/linux-kernel/2002-25/0687.html)
"I notice that none of the current softirq routines use the data element
passed to them."
and the situation hasn't changed since them. So it appears we can safely
remove that extra argument to save 128 (54) bytes of kernel data (text).
Signed-off-by: Carlos R. Mafra <crmafra@ift.unesp.br>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-15 21:15:37 +07:00
|
|
|
open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
|
2006-12-10 17:20:25 +07:00
|
|
|
#endif
|
|
|
|
|
2006-07-30 17:03:52 +07:00
|
|
|
#ifdef CONFIG_RT_MUTEXES
|
2009-11-17 20:54:03 +07:00
|
|
|
plist_head_init_raw(&init_task.pi_waiters, &init_task.pi_lock);
|
2006-07-30 17:03:52 +07:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* The boot idle thread does lazy MMU switching as well:
|
|
|
|
*/
|
|
|
|
atomic_inc(&init_mm.mm_count);
|
|
|
|
enter_lazy_tlb(&init_mm, current);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make us the idle thread. Technically, schedule() should not be
|
|
|
|
* called from this thread, however somewhere below it might be,
|
|
|
|
* but because we are the idle thread, we just pick up running again
|
|
|
|
* when this runqueue becomes "idle".
|
|
|
|
*/
|
|
|
|
init_idle(current, smp_processor_id());
|
2009-04-11 15:43:41 +07:00
|
|
|
|
|
|
|
calc_load_update = jiffies + LOAD_FREQ;
|
|
|
|
|
2007-07-09 23:51:59 +07:00
|
|
|
/*
|
|
|
|
* During early bootup we pretend to be a normal task:
|
|
|
|
*/
|
|
|
|
current->sched_class = &fair_sched_class;
|
2008-02-13 20:02:36 +07:00
|
|
|
|
2008-11-24 23:05:04 +07:00
|
|
|
/* Allocate the nohz_cpu_mask if CONFIG_CPUMASK_OFFSTACK */
|
2009-11-02 17:07:20 +07:00
|
|
|
zalloc_cpumask_var(&nohz_cpu_mask, GFP_NOWAIT);
|
2008-11-25 06:27:51 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2008-11-24 23:05:09 +07:00
|
|
|
#ifdef CONFIG_NO_HZ
|
2009-11-02 17:07:20 +07:00
|
|
|
zalloc_cpumask_var(&nohz.cpu_mask, GFP_NOWAIT);
|
2009-06-11 12:35:27 +07:00
|
|
|
alloc_cpumask_var(&nohz.ilb_grp_nohz_mask, GFP_NOWAIT);
|
2008-11-24 23:05:09 +07:00
|
|
|
#endif
|
2009-12-02 10:39:16 +07:00
|
|
|
/* May be allocated at isolcpus cmdline parse time */
|
|
|
|
if (cpu_isolated_map == NULL)
|
|
|
|
zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT);
|
2008-11-25 06:27:51 +07:00
|
|
|
#endif /* SMP */
|
2008-11-24 23:05:04 +07:00
|
|
|
|
perf: Do the big rename: Performance Counters -> Performance Events
Bye-bye Performance Counters, welcome Performance Events!
In the past few months the perfcounters subsystem has grown out its
initial role of counting hardware events, and has become (and is
becoming) a much broader generic event enumeration, reporting, logging,
monitoring, analysis facility.
Naming its core object 'perf_counter' and naming the subsystem
'perfcounters' has become more and more of a misnomer. With pending
code like hw-breakpoints support the 'counter' name is less and
less appropriate.
All in one, we've decided to rename the subsystem to 'performance
events' and to propagate this rename through all fields, variables
and API names. (in an ABI compatible fashion)
The word 'event' is also a bit shorter than 'counter' - which makes
it slightly more convenient to write/handle as well.
Thanks goes to Stephane Eranian who first observed this misnomer and
suggested a rename.
User-space tooling and ABI compatibility is not affected - this patch
should be function-invariant. (Also, defconfigs were not touched to
keep the size down.)
This patch has been generated via the following script:
FILES=$(find * -type f | grep -vE 'oprofile|[^K]config')
sed -i \
-e 's/PERF_EVENT_/PERF_RECORD_/g' \
-e 's/PERF_COUNTER/PERF_EVENT/g' \
-e 's/perf_counter/perf_event/g' \
-e 's/nb_counters/nb_events/g' \
-e 's/swcounter/swevent/g' \
-e 's/tpcounter_event/tp_event/g' \
$FILES
for N in $(find . -name perf_counter.[ch]); do
M=$(echo $N | sed 's/perf_counter/perf_event/g')
mv $N $M
done
FILES=$(find . -name perf_event.*)
sed -i \
-e 's/COUNTER_MASK/REG_MASK/g' \
-e 's/COUNTER/EVENT/g' \
-e 's/\<event\>/event_id/g' \
-e 's/counter/event/g' \
-e 's/Counter/Event/g' \
$FILES
... to keep it as correct as possible. This script can also be
used by anyone who has pending perfcounters patches - it converts
a Linux kernel tree over to the new naming. We tried to time this
change to the point in time where the amount of pending patches
is the smallest: the end of the merge window.
Namespace clashes were fixed up in a preparatory patch - and some
stylistic fallout will be fixed up in a subsequent patch.
( NOTE: 'counters' are still the proper terminology when we deal
with hardware registers - and these sed scripts are a bit
over-eager in renaming them. I've undone some of that, but
in case there's something left where 'counter' would be
better than 'event' we can undo that on an individual basis
instead of touching an otherwise nicely automated patch. )
Suggested-by: Stephane Eranian <eranian@google.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Paul Mackerras <paulus@samba.org>
Reviewed-by: Arjan van de Ven <arjan@linux.intel.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: <linux-arch@vger.kernel.org>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-09-21 17:02:48 +07:00
|
|
|
perf_event_init();
|
2009-05-05 00:13:30 +07:00
|
|
|
|
2008-02-13 20:02:36 +07:00
|
|
|
scheduler_running = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
|
2009-07-16 20:44:29 +07:00
|
|
|
static inline int preempt_count_equals(int preempt_offset)
|
|
|
|
{
|
2009-12-17 02:21:05 +07:00
|
|
|
int nested = (preempt_count() & ~PREEMPT_ACTIVE) + rcu_preempt_depth();
|
2009-07-16 20:44:29 +07:00
|
|
|
|
|
|
|
return (nested == PREEMPT_INATOMIC_BASE + preempt_offset);
|
|
|
|
}
|
|
|
|
|
2009-12-23 17:08:18 +07:00
|
|
|
void __might_sleep(const char *file, int line, int preempt_offset)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-07-03 14:25:40 +07:00
|
|
|
#ifdef in_atomic
|
2005-04-17 05:20:36 +07:00
|
|
|
static unsigned long prev_jiffy; /* ratelimiting */
|
|
|
|
|
2009-07-16 20:44:29 +07:00
|
|
|
if ((preempt_count_equals(preempt_offset) && !irqs_disabled()) ||
|
|
|
|
system_state != SYSTEM_RUNNING || oops_in_progress)
|
2008-08-28 16:34:43 +07:00
|
|
|
return;
|
|
|
|
if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
|
|
|
|
return;
|
|
|
|
prev_jiffy = jiffies;
|
|
|
|
|
2009-12-20 20:23:57 +07:00
|
|
|
printk(KERN_ERR
|
|
|
|
"BUG: sleeping function called from invalid context at %s:%d\n",
|
|
|
|
file, line);
|
|
|
|
printk(KERN_ERR
|
|
|
|
"in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
|
|
|
|
in_atomic(), irqs_disabled(),
|
|
|
|
current->pid, current->comm);
|
2008-08-28 16:34:43 +07:00
|
|
|
|
|
|
|
debug_show_held_locks(current);
|
|
|
|
if (irqs_disabled())
|
|
|
|
print_irqtrace_events(current);
|
|
|
|
dump_stack();
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__might_sleep);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAGIC_SYSRQ
|
2007-10-15 22:00:15 +07:00
|
|
|
static void normalize_task(struct rq *rq, struct task_struct *p)
|
|
|
|
{
|
|
|
|
int on_rq;
|
2008-05-03 23:29:28 +07:00
|
|
|
|
2007-10-15 22:00:15 +07:00
|
|
|
on_rq = p->se.on_rq;
|
|
|
|
if (on_rq)
|
|
|
|
deactivate_task(rq, p, 0);
|
|
|
|
__setscheduler(rq, p, SCHED_NORMAL, 0);
|
|
|
|
if (on_rq) {
|
|
|
|
activate_task(rq, p, 0);
|
|
|
|
resched_task(rq->curr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
void normalize_rt_tasks(void)
|
|
|
|
{
|
2007-06-17 23:37:45 +07:00
|
|
|
struct task_struct *g, *p;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
2006-07-03 14:25:42 +07:00
|
|
|
struct rq *rq;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
read_lock_irqsave(&tasklist_lock, flags);
|
2007-06-17 23:37:45 +07:00
|
|
|
do_each_thread(g, p) {
|
2007-10-15 22:00:18 +07:00
|
|
|
/*
|
|
|
|
* Only normalize user tasks:
|
|
|
|
*/
|
|
|
|
if (!p->mm)
|
|
|
|
continue;
|
|
|
|
|
2007-08-02 22:41:40 +07:00
|
|
|
p->se.exec_start = 0;
|
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
2010-03-11 09:37:45 +07:00
|
|
|
p->se.statistics.wait_start = 0;
|
|
|
|
p->se.statistics.sleep_start = 0;
|
|
|
|
p->se.statistics.block_start = 0;
|
2007-08-02 22:41:40 +07:00
|
|
|
#endif
|
2007-07-09 23:51:59 +07:00
|
|
|
|
|
|
|
if (!rt_task(p)) {
|
|
|
|
/*
|
|
|
|
* Renice negative nice level userspace
|
|
|
|
* tasks back to 0:
|
|
|
|
*/
|
|
|
|
if (TASK_NICE(p) < 0 && p->mm)
|
|
|
|
set_user_nice(p, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
2007-07-09 23:51:59 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-11-17 20:54:03 +07:00
|
|
|
raw_spin_lock(&p->pi_lock);
|
2006-06-27 16:54:51 +07:00
|
|
|
rq = __task_rq_lock(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 22:00:18 +07:00
|
|
|
normalize_task(rq, p);
|
2007-10-15 22:00:15 +07:00
|
|
|
|
2006-06-27 16:54:51 +07:00
|
|
|
__task_rq_unlock(rq);
|
2009-11-17 20:54:03 +07:00
|
|
|
raw_spin_unlock(&p->pi_lock);
|
2007-06-17 23:37:45 +07:00
|
|
|
} while_each_thread(g, p);
|
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
read_unlock_irqrestore(&tasklist_lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_MAGIC_SYSRQ */
|
2005-09-12 21:59:21 +07:00
|
|
|
|
2010-05-21 09:04:21 +07:00
|
|
|
#if defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB)
|
2005-09-12 21:59:21 +07:00
|
|
|
/*
|
2010-05-21 09:04:21 +07:00
|
|
|
* These functions are only useful for the IA64 MCA handling, or kdb.
|
2005-09-12 21:59:21 +07:00
|
|
|
*
|
|
|
|
* They can only be called when the whole system has been
|
|
|
|
* stopped - every CPU needs to be quiescent, and no scheduling
|
|
|
|
* activity can take place. Using them for anything else would
|
|
|
|
* be a serious bug, and as a result, they aren't even visible
|
|
|
|
* under any other configuration.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* curr_task - return the current task for a given cpu.
|
|
|
|
* @cpu: the processor in question.
|
|
|
|
*
|
|
|
|
* ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
struct task_struct *curr_task(int cpu)
|
2005-09-12 21:59:21 +07:00
|
|
|
{
|
|
|
|
return cpu_curr(cpu);
|
|
|
|
}
|
|
|
|
|
2010-05-21 09:04:21 +07:00
|
|
|
#endif /* defined(CONFIG_IA64) || defined(CONFIG_KGDB_KDB) */
|
|
|
|
|
|
|
|
#ifdef CONFIG_IA64
|
2005-09-12 21:59:21 +07:00
|
|
|
/**
|
|
|
|
* set_curr_task - set the current task for a given cpu.
|
|
|
|
* @cpu: the processor in question.
|
|
|
|
* @p: the task pointer to set.
|
|
|
|
*
|
|
|
|
* Description: This function must only be used when non-maskable interrupts
|
2007-12-05 21:46:09 +07:00
|
|
|
* are serviced on a separate stack. It allows the architecture to switch the
|
|
|
|
* notion of the current task on a cpu in a non-blocking manner. This function
|
2005-09-12 21:59:21 +07:00
|
|
|
* must be called with all CPU's synchronized, and interrupts disabled, the
|
|
|
|
* and caller must save the original value of the current task (see
|
|
|
|
* curr_task() above) and restore that value before reenabling interrupts and
|
|
|
|
* re-starting the system.
|
|
|
|
*
|
|
|
|
* ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
|
|
|
|
*/
|
2006-07-03 14:25:41 +07:00
|
|
|
void set_curr_task(int cpu, struct task_struct *p)
|
2005-09-12 21:59:21 +07:00
|
|
|
{
|
|
|
|
cpu_curr(cpu) = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
static void free_fair_sched_group(struct task_group *tg)
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
if (tg->cfs_rq)
|
|
|
|
kfree(tg->cfs_rq[i]);
|
|
|
|
if (tg->se)
|
|
|
|
kfree(tg->se[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(tg->cfs_rq);
|
|
|
|
kfree(tg->se);
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
static
|
|
|
|
int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
|
2007-10-15 22:00:07 +07:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq;
|
2008-10-29 16:03:22 +07:00
|
|
|
struct sched_entity *se;
|
2007-10-15 22:00:09 +07:00
|
|
|
struct rq *rq;
|
2007-10-15 22:00:07 +07:00
|
|
|
int i;
|
|
|
|
|
2008-04-05 08:11:04 +07:00
|
|
|
tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
|
2007-10-15 22:00:07 +07:00
|
|
|
if (!tg->cfs_rq)
|
|
|
|
goto err;
|
2008-04-05 08:11:04 +07:00
|
|
|
tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
|
2007-10-15 22:00:07 +07:00
|
|
|
if (!tg->se)
|
|
|
|
goto err;
|
2008-02-13 21:45:40 +07:00
|
|
|
|
|
|
|
tg->shares = NICE_0_LOAD;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
2007-10-15 22:00:09 +07:00
|
|
|
rq = cpu_rq(i);
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-10-29 16:03:22 +07:00
|
|
|
cfs_rq = kzalloc_node(sizeof(struct cfs_rq),
|
|
|
|
GFP_KERNEL, cpu_to_node(i));
|
2007-10-15 22:00:07 +07:00
|
|
|
if (!cfs_rq)
|
|
|
|
goto err;
|
|
|
|
|
2008-10-29 16:03:22 +07:00
|
|
|
se = kzalloc_node(sizeof(struct sched_entity),
|
|
|
|
GFP_KERNEL, cpu_to_node(i));
|
2007-10-15 22:00:07 +07:00
|
|
|
if (!se)
|
2009-12-10 19:29:37 +07:00
|
|
|
goto err_free_rq;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-10-29 16:03:22 +07:00
|
|
|
init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent->se[i]);
|
2008-02-13 21:45:40 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
2009-12-10 19:29:37 +07:00
|
|
|
err_free_rq:
|
|
|
|
kfree(cfs_rq);
|
2008-02-13 21:45:40 +07:00
|
|
|
err:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void register_fair_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
list_add_rcu(&tg->cfs_rq[cpu]->leaf_cfs_rq_list,
|
|
|
|
&cpu_rq(cpu)->leaf_cfs_rq_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
list_del_rcu(&tg->cfs_rq[cpu]->leaf_cfs_rq_list);
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFG_FAIR_GROUP_SCHED */
|
2008-02-13 21:45:40 +07:00
|
|
|
static inline void free_fair_sched_group(struct task_group *tg)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
static inline
|
|
|
|
int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
|
2008-02-13 21:45:40 +07:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void register_fair_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
2008-02-13 21:45:40 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-02-13 21:45:40 +07:00
|
|
|
static void free_rt_sched_group(struct task_group *tg)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
destroy_rt_bandwidth(&tg->rt_bandwidth);
|
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
if (tg->rt_rq)
|
|
|
|
kfree(tg->rt_rq[i]);
|
|
|
|
if (tg->rt_se)
|
|
|
|
kfree(tg->rt_se[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(tg->rt_rq);
|
|
|
|
kfree(tg->rt_se);
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
static
|
|
|
|
int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
|
2008-02-13 21:45:40 +07:00
|
|
|
{
|
|
|
|
struct rt_rq *rt_rq;
|
2008-10-29 16:03:22 +07:00
|
|
|
struct sched_rt_entity *rt_se;
|
2008-02-13 21:45:40 +07:00
|
|
|
struct rq *rq;
|
|
|
|
int i;
|
|
|
|
|
2008-04-05 08:11:04 +07:00
|
|
|
tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
|
2008-02-13 21:45:40 +07:00
|
|
|
if (!tg->rt_rq)
|
|
|
|
goto err;
|
2008-04-05 08:11:04 +07:00
|
|
|
tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
|
2008-02-13 21:45:40 +07:00
|
|
|
if (!tg->rt_se)
|
|
|
|
goto err;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
init_rt_bandwidth(&tg->rt_bandwidth,
|
|
|
|
ktime_to_ns(def_rt_bandwidth.rt_period), 0);
|
2008-02-13 21:45:40 +07:00
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
rq = cpu_rq(i);
|
|
|
|
|
2008-10-29 16:03:22 +07:00
|
|
|
rt_rq = kzalloc_node(sizeof(struct rt_rq),
|
|
|
|
GFP_KERNEL, cpu_to_node(i));
|
2008-01-26 03:08:30 +07:00
|
|
|
if (!rt_rq)
|
|
|
|
goto err;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-10-29 16:03:22 +07:00
|
|
|
rt_se = kzalloc_node(sizeof(struct sched_rt_entity),
|
|
|
|
GFP_KERNEL, cpu_to_node(i));
|
2008-01-26 03:08:30 +07:00
|
|
|
if (!rt_se)
|
2009-12-10 19:29:37 +07:00
|
|
|
goto err_free_rq;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-10-29 16:03:22 +07:00
|
|
|
init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent->rt_se[i]);
|
2007-10-15 22:00:07 +07:00
|
|
|
}
|
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
return 1;
|
|
|
|
|
2009-12-10 19:29:37 +07:00
|
|
|
err_free_rq:
|
|
|
|
kfree(rt_rq);
|
2008-02-13 21:45:40 +07:00
|
|
|
err:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void register_rt_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
list_add_rcu(&tg->rt_rq[cpu]->leaf_rt_rq_list,
|
|
|
|
&cpu_rq(cpu)->leaf_rt_rq_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
list_del_rcu(&tg->rt_rq[cpu]->leaf_rt_rq_list);
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFIG_RT_GROUP_SCHED */
|
2008-02-13 21:45:40 +07:00
|
|
|
static inline void free_rt_sched_group(struct task_group *tg)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
static inline
|
|
|
|
int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
|
2008-02-13 21:45:40 +07:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void register_rt_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
|
|
|
|
{
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_RT_GROUP_SCHED */
|
2008-02-13 21:45:40 +07:00
|
|
|
|
2010-01-20 19:26:18 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
2008-02-13 21:45:40 +07:00
|
|
|
static void free_sched_group(struct task_group *tg)
|
|
|
|
{
|
|
|
|
free_fair_sched_group(tg);
|
|
|
|
free_rt_sched_group(tg);
|
|
|
|
kfree(tg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate runqueue etc for a new task group */
|
2008-04-20 00:44:59 +07:00
|
|
|
struct task_group *sched_create_group(struct task_group *parent)
|
2008-02-13 21:45:40 +07:00
|
|
|
{
|
|
|
|
struct task_group *tg;
|
|
|
|
unsigned long flags;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
tg = kzalloc(sizeof(*tg), GFP_KERNEL);
|
|
|
|
if (!tg)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
if (!alloc_fair_sched_group(tg, parent))
|
2008-02-13 21:45:40 +07:00
|
|
|
goto err;
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
if (!alloc_rt_sched_group(tg, parent))
|
2008-02-13 21:45:40 +07:00
|
|
|
goto err;
|
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_lock_irqsave(&task_group_lock, flags);
|
2007-10-15 22:00:09 +07:00
|
|
|
for_each_possible_cpu(i) {
|
2008-02-13 21:45:40 +07:00
|
|
|
register_fair_sched_group(tg, i);
|
|
|
|
register_rt_sched_group(tg, i);
|
2007-10-15 22:00:09 +07:00
|
|
|
}
|
2008-01-26 03:08:30 +07:00
|
|
|
list_add_rcu(&tg->list, &task_groups);
|
2008-04-20 00:45:00 +07:00
|
|
|
|
|
|
|
WARN_ON(!parent); /* root should already exist */
|
|
|
|
|
|
|
|
tg->parent = parent;
|
|
|
|
INIT_LIST_HEAD(&tg->children);
|
2030-08-14 14:56:40 +07:00
|
|
|
list_add_rcu(&tg->siblings, &parent->children);
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_unlock_irqrestore(&task_group_lock, flags);
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2007-10-15 22:00:09 +07:00
|
|
|
return tg;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
|
|
|
err:
|
2008-01-26 03:08:30 +07:00
|
|
|
free_sched_group(tg);
|
2007-10-15 22:00:07 +07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:09 +07:00
|
|
|
/* rcu callback to free various structures associated with a task group */
|
2008-01-26 03:08:30 +07:00
|
|
|
static void free_sched_group_rcu(struct rcu_head *rhp)
|
2007-10-15 22:00:07 +07:00
|
|
|
{
|
|
|
|
/* now it should be safe to free those cfs_rqs */
|
2008-01-26 03:08:30 +07:00
|
|
|
free_sched_group(container_of(rhp, struct task_group, rcu));
|
2007-10-15 22:00:07 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:09 +07:00
|
|
|
/* Destroy runqueue etc associated with a task group */
|
2007-10-15 22:00:14 +07:00
|
|
|
void sched_destroy_group(struct task_group *tg)
|
2007-10-15 22:00:07 +07:00
|
|
|
{
|
2008-02-13 21:45:39 +07:00
|
|
|
unsigned long flags;
|
2007-10-15 22:00:09 +07:00
|
|
|
int i;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_lock_irqsave(&task_group_lock, flags);
|
2007-10-15 22:00:09 +07:00
|
|
|
for_each_possible_cpu(i) {
|
2008-02-13 21:45:40 +07:00
|
|
|
unregister_fair_sched_group(tg, i);
|
|
|
|
unregister_rt_sched_group(tg, i);
|
2007-10-15 22:00:09 +07:00
|
|
|
}
|
2008-01-26 03:08:30 +07:00
|
|
|
list_del_rcu(&tg->list);
|
2008-04-20 00:45:00 +07:00
|
|
|
list_del_rcu(&tg->siblings);
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_unlock_irqrestore(&task_group_lock, flags);
|
2007-10-15 22:00:09 +07:00
|
|
|
|
|
|
|
/* wait for possible concurrent references to cfs_rqs complete */
|
2008-01-26 03:08:30 +07:00
|
|
|
call_rcu(&tg->rcu, free_sched_group_rcu);
|
2007-10-15 22:00:07 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:09 +07:00
|
|
|
/* change task's runqueue when it moves between groups.
|
2007-10-15 22:00:12 +07:00
|
|
|
* The caller of this function should have put the task in its new group
|
|
|
|
* by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to
|
|
|
|
* reflect its new group.
|
2007-10-15 22:00:09 +07:00
|
|
|
*/
|
|
|
|
void sched_move_task(struct task_struct *tsk)
|
2007-10-15 22:00:07 +07:00
|
|
|
{
|
|
|
|
int on_rq, running;
|
|
|
|
unsigned long flags;
|
|
|
|
struct rq *rq;
|
|
|
|
|
|
|
|
rq = task_rq_lock(tsk, &flags);
|
|
|
|
|
2007-12-18 21:21:13 +07:00
|
|
|
running = task_current(rq, tsk);
|
2007-10-15 22:00:07 +07:00
|
|
|
on_rq = tsk->se.on_rq;
|
|
|
|
|
2008-03-11 01:01:20 +07:00
|
|
|
if (on_rq)
|
2007-10-15 22:00:07 +07:00
|
|
|
dequeue_task(rq, tsk, 0);
|
2008-03-11 01:01:20 +07:00
|
|
|
if (unlikely(running))
|
|
|
|
tsk->sched_class->put_prev_task(rq, tsk);
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-01-26 03:08:30 +07:00
|
|
|
set_task_rq(tsk, task_cpu(tsk));
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-03-01 03:21:01 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
if (tsk->sched_class->moved_group)
|
sched: Remove the cfs_rq dependency from set_task_cpu()
In order to remove the cfs_rq dependency from set_task_cpu() we
need to ensure the task is cfs_rq invariant for all callsites.
The simple approach is to substract cfs_rq->min_vruntime from
se->vruntime on dequeue, and add cfs_rq->min_vruntime on
enqueue.
However, this has the downside of breaking FAIR_SLEEPERS since
we loose the old vruntime as we only maintain the relative
position.
To solve this, we observe that we only migrate runnable tasks,
we do this using deactivate_task(.sleep=0) and
activate_task(.wakeup=0), therefore we can restrain the
min_vruntime invariance to that state.
The only other case is wakeup balancing, since we want to
maintain the old vruntime we cannot make it relative on dequeue,
but since we don't migrate inactive tasks, we can do so right
before we activate it again.
This is where we need the new pre-wakeup hook, we need to call
this while still holding the old rq->lock. We could fold it into
->select_task_rq(), but since that has multiple callsites and
would obfuscate the locking requirements, that seems like a
fudge.
This leaves the fork() case, simply make sure that ->task_fork()
leaves the ->vruntime in a relative state.
This covers all cases where set_task_cpu() gets called, and
ensures it sees a relative vruntime.
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091216170518.191697025@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-17 00:04:41 +07:00
|
|
|
tsk->sched_class->moved_group(tsk, on_rq);
|
2008-03-01 03:21:01 +07:00
|
|
|
#endif
|
|
|
|
|
2008-03-11 01:01:20 +07:00
|
|
|
if (unlikely(running))
|
|
|
|
tsk->sched_class->set_curr_task(rq);
|
|
|
|
if (on_rq)
|
2010-03-24 22:38:48 +07:00
|
|
|
enqueue_task(rq, tsk, 0);
|
2007-10-15 22:00:07 +07:00
|
|
|
|
|
|
|
task_rq_unlock(rq, &flags);
|
|
|
|
}
|
2010-01-20 19:26:18 +07:00
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2008-06-27 18:41:14 +07:00
|
|
|
static void __set_se_shares(struct sched_entity *se, unsigned long shares)
|
2007-10-15 22:00:07 +07:00
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = se->cfs_rq;
|
|
|
|
int on_rq;
|
|
|
|
|
|
|
|
on_rq = se->on_rq;
|
2008-02-25 23:34:02 +07:00
|
|
|
if (on_rq)
|
2007-10-15 22:00:07 +07:00
|
|
|
dequeue_entity(cfs_rq, se, 0);
|
|
|
|
|
|
|
|
se->load.weight = shares;
|
2008-05-06 04:56:17 +07:00
|
|
|
se->load.inv_weight = 0;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-02-25 23:34:02 +07:00
|
|
|
if (on_rq)
|
2007-10-15 22:00:07 +07:00
|
|
|
enqueue_entity(cfs_rq, se, 0);
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
2008-02-25 23:34:02 +07:00
|
|
|
|
2008-06-27 18:41:14 +07:00
|
|
|
static void set_se_shares(struct sched_entity *se, unsigned long shares)
|
|
|
|
{
|
|
|
|
struct cfs_rq *cfs_rq = se->cfs_rq;
|
|
|
|
struct rq *rq = cfs_rq->rq;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irqsave(&rq->lock, flags);
|
2008-06-27 18:41:14 +07:00
|
|
|
__set_se_shares(se, shares);
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irqrestore(&rq->lock, flags);
|
2007-10-15 22:00:07 +07:00
|
|
|
}
|
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
static DEFINE_MUTEX(shares_mutex);
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
int sched_group_set_shares(struct task_group *tg, unsigned long shares)
|
2007-10-15 22:00:07 +07:00
|
|
|
{
|
|
|
|
int i;
|
2008-02-13 21:45:39 +07:00
|
|
|
unsigned long flags;
|
2008-01-22 17:24:58 +07:00
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
/*
|
|
|
|
* We can't change the weight of the root cgroup.
|
|
|
|
*/
|
|
|
|
if (!tg->se[0])
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-20 00:45:00 +07:00
|
|
|
if (shares < MIN_SHARES)
|
|
|
|
shares = MIN_SHARES;
|
sched: fair-group: fix a Div0 error of the fair group scheduler
When I echoed 0 into the "cpu.shares" file, a Div0 error occured.
We found it is caused by the following calling.
sched_group_set_shares(tg, shares)
set_se_shares(tg->se[i], shares/nr_cpu_ids)
__set_se_shares(se, shares)
div64_64((1ULL<<32), shares)
When the echoed value was less than the number of processores, the result of the
sentence "shares/nr_cpu_ids" was 0, and then the system called div64() to divide
the result, the Div0 error occured.
It is unnecessary that the shares value is divided by nr_cpu_ids, I think.
Because in the function __update_group_shares_cpu() and init_tg_cfs_entry(),
the shares value isn't divided by nr_cpu_ids when setting shares of the sched
entity.
This patch fixes this bug. And echoing ULONG_MAX value into cpu.shares also
causes Div0 error, so we set a macro MAX_SHARES to limit the max value of
shares.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-04-28 11:54:56 +07:00
|
|
|
else if (shares > MAX_SHARES)
|
|
|
|
shares = MAX_SHARES;
|
2008-02-25 23:34:02 +07:00
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
mutex_lock(&shares_mutex);
|
2007-10-15 22:00:09 +07:00
|
|
|
if (tg->shares == shares)
|
2007-10-15 22:00:14 +07:00
|
|
|
goto done;
|
2007-10-15 22:00:07 +07:00
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_lock_irqsave(&task_group_lock, flags);
|
2008-02-13 21:45:40 +07:00
|
|
|
for_each_possible_cpu(i)
|
|
|
|
unregister_fair_sched_group(tg, i);
|
2008-04-20 00:45:00 +07:00
|
|
|
list_del_rcu(&tg->siblings);
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_unlock_irqrestore(&task_group_lock, flags);
|
sched: group scheduler, fix fairness of cpu bandwidth allocation for task groups
The current load balancing scheme isn't good enough for precise
group fairness.
For example: on a 8-cpu system, I created 3 groups as under:
a = 8 tasks (cpu.shares = 1024)
b = 4 tasks (cpu.shares = 1024)
c = 3 tasks (cpu.shares = 1024)
a, b and c are task groups that have equal weight. We would expect each
of the groups to receive 33.33% of cpu bandwidth under a fair scheduler.
This is what I get with the latest scheduler git tree:
Signed-off-by: Ingo Molnar <mingo@elte.hu>
--------------------------------------------------------------------------------
Col1 | Col2 | Col3 | Col4
------|---------|-------|-------------------------------------------------------
a | 277.676 | 57.8% | 54.1% 54.1% 54.1% 54.2% 56.7% 62.2% 62.8% 64.5%
b | 116.108 | 24.2% | 47.4% 48.1% 48.7% 49.3%
c | 86.326 | 18.0% | 47.5% 47.9% 48.5%
--------------------------------------------------------------------------------
Explanation of o/p:
Col1 -> Group name
Col2 -> Cumulative execution time (in seconds) received by all tasks of that
group in a 60sec window across 8 cpus
Col3 -> CPU bandwidth received by the group in the 60sec window, expressed in
percentage. Col3 data is derived as:
Col3 = 100 * Col2 / (NR_CPUS * 60)
Col4 -> CPU bandwidth received by each individual task of the group.
Col4 = 100 * cpu_time_recd_by_task / 60
[I can share the test case that produces a similar o/p if reqd]
The deviation from desired group fairness is as below:
a = +24.47%
b = -9.13%
c = -15.33%
which is quite high.
After the patch below is applied, here are the results:
--------------------------------------------------------------------------------
Col1 | Col2 | Col3 | Col4
------|---------|-------|-------------------------------------------------------
a | 163.112 | 34.0% | 33.2% 33.4% 33.5% 33.5% 33.7% 34.4% 34.8% 35.3%
b | 156.220 | 32.5% | 63.3% 64.5% 66.1% 66.5%
c | 160.653 | 33.5% | 85.8% 90.6% 91.4%
--------------------------------------------------------------------------------
Deviation from desired group fairness is as below:
a = +0.67%
b = -0.83%
c = +0.17%
which is far better IMO. Most of other runs have yielded a deviation within
+-2% at the most, which is good.
Why do we see bad (group) fairness with current scheuler?
=========================================================
Currently cpu's weight is just the summation of individual task weights.
This can yield incorrect results. For ex: consider three groups as below
on a 2-cpu system:
CPU0 CPU1
---------------------------
A (10) B(5)
C(5)
---------------------------
Group A has 10 tasks, all on CPU0, Group B and C have 5 tasks each all
of which are on CPU1. Each task has the same weight (NICE_0_LOAD =
1024).
The current scheme would yield a cpu weight of 10240 (10*1024) for each cpu and
the load balancer will think both CPUs are perfectly balanced and won't
move around any tasks. This, however, would yield this bandwidth:
A = 50%
B = 25%
C = 25%
which is not the desired result.
What's changing in the patch?
=============================
- How cpu weights are calculated when CONFIF_FAIR_GROUP_SCHED is
defined (see below)
- API Change
- Two tunables introduced in sysfs (under SCHED_DEBUG) to
control the frequency at which the load balance monitor
thread runs.
The basic change made in this patch is how cpu weight (rq->load.weight) is
calculated. Its now calculated as the summation of group weights on a cpu,
rather than summation of task weights. Weight exerted by a group on a
cpu is dependent on the shares allocated to it and also the number of
tasks the group has on that cpu compared to the total number of
(runnable) tasks the group has in the system.
Let,
W(K,i) = Weight of group K on cpu i
T(K,i) = Task load present in group K's cfs_rq on cpu i
T(K) = Total task load of group K across various cpus
S(K) = Shares allocated to group K
NRCPUS = Number of online cpus in the scheduler domain to
which group K is assigned.
Then,
W(K,i) = S(K) * NRCPUS * T(K,i) / T(K)
A load balance monitor thread is created at bootup, which periodically
runs and adjusts group's weight on each cpu. To avoid its overhead, two
min/max tunables are introduced (under SCHED_DEBUG) to control the rate
at which it runs.
Fixes from: Peter Zijlstra <a.p.zijlstra@chello.nl>
- don't start the load_balance_monitor when there is only a single cpu.
- rename the kthread because its currently longer than TASK_COMM_LEN
Signed-off-by: Srivatsa Vaddagiri <vatsa@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-01-26 03:08:00 +07:00
|
|
|
|
|
|
|
/* wait for any ongoing reference to this group to finish */
|
|
|
|
synchronize_sched();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now we are free to modify the group's share on each cpu
|
|
|
|
* w/o tripping rebalance_share or load_balance_fair.
|
|
|
|
*/
|
2007-10-15 22:00:09 +07:00
|
|
|
tg->shares = shares;
|
2008-06-27 18:41:14 +07:00
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
/*
|
|
|
|
* force a rebalance
|
|
|
|
*/
|
|
|
|
cfs_rq_set_shares(tg->cfs_rq[i], 0);
|
sched: fair-group: fix a Div0 error of the fair group scheduler
When I echoed 0 into the "cpu.shares" file, a Div0 error occured.
We found it is caused by the following calling.
sched_group_set_shares(tg, shares)
set_se_shares(tg->se[i], shares/nr_cpu_ids)
__set_se_shares(se, shares)
div64_64((1ULL<<32), shares)
When the echoed value was less than the number of processores, the result of the
sentence "shares/nr_cpu_ids" was 0, and then the system called div64() to divide
the result, the Div0 error occured.
It is unnecessary that the shares value is divided by nr_cpu_ids, I think.
Because in the function __update_group_shares_cpu() and init_tg_cfs_entry(),
the shares value isn't divided by nr_cpu_ids when setting shares of the sched
entity.
This patch fixes this bug. And echoing ULONG_MAX value into cpu.shares also
causes Div0 error, so we set a macro MAX_SHARES to limit the max value of
shares.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-04-28 11:54:56 +07:00
|
|
|
set_se_shares(tg->se[i], shares);
|
2008-06-27 18:41:14 +07:00
|
|
|
}
|
2007-10-15 22:00:07 +07:00
|
|
|
|
sched: group scheduler, fix fairness of cpu bandwidth allocation for task groups
The current load balancing scheme isn't good enough for precise
group fairness.
For example: on a 8-cpu system, I created 3 groups as under:
a = 8 tasks (cpu.shares = 1024)
b = 4 tasks (cpu.shares = 1024)
c = 3 tasks (cpu.shares = 1024)
a, b and c are task groups that have equal weight. We would expect each
of the groups to receive 33.33% of cpu bandwidth under a fair scheduler.
This is what I get with the latest scheduler git tree:
Signed-off-by: Ingo Molnar <mingo@elte.hu>
--------------------------------------------------------------------------------
Col1 | Col2 | Col3 | Col4
------|---------|-------|-------------------------------------------------------
a | 277.676 | 57.8% | 54.1% 54.1% 54.1% 54.2% 56.7% 62.2% 62.8% 64.5%
b | 116.108 | 24.2% | 47.4% 48.1% 48.7% 49.3%
c | 86.326 | 18.0% | 47.5% 47.9% 48.5%
--------------------------------------------------------------------------------
Explanation of o/p:
Col1 -> Group name
Col2 -> Cumulative execution time (in seconds) received by all tasks of that
group in a 60sec window across 8 cpus
Col3 -> CPU bandwidth received by the group in the 60sec window, expressed in
percentage. Col3 data is derived as:
Col3 = 100 * Col2 / (NR_CPUS * 60)
Col4 -> CPU bandwidth received by each individual task of the group.
Col4 = 100 * cpu_time_recd_by_task / 60
[I can share the test case that produces a similar o/p if reqd]
The deviation from desired group fairness is as below:
a = +24.47%
b = -9.13%
c = -15.33%
which is quite high.
After the patch below is applied, here are the results:
--------------------------------------------------------------------------------
Col1 | Col2 | Col3 | Col4
------|---------|-------|-------------------------------------------------------
a | 163.112 | 34.0% | 33.2% 33.4% 33.5% 33.5% 33.7% 34.4% 34.8% 35.3%
b | 156.220 | 32.5% | 63.3% 64.5% 66.1% 66.5%
c | 160.653 | 33.5% | 85.8% 90.6% 91.4%
--------------------------------------------------------------------------------
Deviation from desired group fairness is as below:
a = +0.67%
b = -0.83%
c = +0.17%
which is far better IMO. Most of other runs have yielded a deviation within
+-2% at the most, which is good.
Why do we see bad (group) fairness with current scheuler?
=========================================================
Currently cpu's weight is just the summation of individual task weights.
This can yield incorrect results. For ex: consider three groups as below
on a 2-cpu system:
CPU0 CPU1
---------------------------
A (10) B(5)
C(5)
---------------------------
Group A has 10 tasks, all on CPU0, Group B and C have 5 tasks each all
of which are on CPU1. Each task has the same weight (NICE_0_LOAD =
1024).
The current scheme would yield a cpu weight of 10240 (10*1024) for each cpu and
the load balancer will think both CPUs are perfectly balanced and won't
move around any tasks. This, however, would yield this bandwidth:
A = 50%
B = 25%
C = 25%
which is not the desired result.
What's changing in the patch?
=============================
- How cpu weights are calculated when CONFIF_FAIR_GROUP_SCHED is
defined (see below)
- API Change
- Two tunables introduced in sysfs (under SCHED_DEBUG) to
control the frequency at which the load balance monitor
thread runs.
The basic change made in this patch is how cpu weight (rq->load.weight) is
calculated. Its now calculated as the summation of group weights on a cpu,
rather than summation of task weights. Weight exerted by a group on a
cpu is dependent on the shares allocated to it and also the number of
tasks the group has on that cpu compared to the total number of
(runnable) tasks the group has in the system.
Let,
W(K,i) = Weight of group K on cpu i
T(K,i) = Task load present in group K's cfs_rq on cpu i
T(K) = Total task load of group K across various cpus
S(K) = Shares allocated to group K
NRCPUS = Number of online cpus in the scheduler domain to
which group K is assigned.
Then,
W(K,i) = S(K) * NRCPUS * T(K,i) / T(K)
A load balance monitor thread is created at bootup, which periodically
runs and adjusts group's weight on each cpu. To avoid its overhead, two
min/max tunables are introduced (under SCHED_DEBUG) to control the rate
at which it runs.
Fixes from: Peter Zijlstra <a.p.zijlstra@chello.nl>
- don't start the load_balance_monitor when there is only a single cpu.
- rename the kthread because its currently longer than TASK_COMM_LEN
Signed-off-by: Srivatsa Vaddagiri <vatsa@linux.vnet.ibm.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-01-26 03:08:00 +07:00
|
|
|
/*
|
|
|
|
* Enable load balance activity on this group, by inserting it back on
|
|
|
|
* each cpu's rq->leaf_cfs_rq_list.
|
|
|
|
*/
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_lock_irqsave(&task_group_lock, flags);
|
2008-02-13 21:45:40 +07:00
|
|
|
for_each_possible_cpu(i)
|
|
|
|
register_fair_sched_group(tg, i);
|
2008-04-20 00:45:00 +07:00
|
|
|
list_add_rcu(&tg->siblings, &tg->parent->children);
|
2008-02-13 21:45:39 +07:00
|
|
|
spin_unlock_irqrestore(&task_group_lock, flags);
|
2007-10-15 22:00:14 +07:00
|
|
|
done:
|
2008-02-13 21:45:39 +07:00
|
|
|
mutex_unlock(&shares_mutex);
|
2007-10-15 22:00:09 +07:00
|
|
|
return 0;
|
2007-10-15 22:00:07 +07:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:00:14 +07:00
|
|
|
unsigned long sched_group_shares(struct task_group *tg)
|
|
|
|
{
|
|
|
|
return tg->shares;
|
|
|
|
}
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
2007-10-15 22:00:14 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-01-26 03:08:30 +07:00
|
|
|
/*
|
2008-02-13 21:45:39 +07:00
|
|
|
* Ensure that the real time constraints are schedulable.
|
2008-01-26 03:08:30 +07:00
|
|
|
*/
|
2008-02-13 21:45:39 +07:00
|
|
|
static DEFINE_MUTEX(rt_constraints_mutex);
|
|
|
|
|
|
|
|
static unsigned long to_ratio(u64 period, u64 runtime)
|
|
|
|
{
|
|
|
|
if (runtime == RUNTIME_INF)
|
2008-08-19 17:33:06 +07:00
|
|
|
return 1ULL << 20;
|
2008-02-13 21:45:39 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
return div64_u64(runtime << 20, period);
|
2008-02-13 21:45:39 +07:00
|
|
|
}
|
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
/* Must be called with tasklist_lock held */
|
|
|
|
static inline int tg_has_rt_tasks(struct task_group *tg)
|
2008-04-20 00:45:00 +07:00
|
|
|
{
|
2008-08-19 17:33:06 +07:00
|
|
|
struct task_struct *g, *p;
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
do_each_thread(g, p) {
|
|
|
|
if (rt_task(p) && rt_rq_of_se(&p->rt)->tg == tg)
|
|
|
|
return 1;
|
|
|
|
} while_each_thread(g, p);
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
struct rt_schedulable_data {
|
|
|
|
struct task_group *tg;
|
|
|
|
u64 rt_period;
|
|
|
|
u64 rt_runtime;
|
|
|
|
};
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
static int tg_schedulable(struct task_group *tg, void *data)
|
|
|
|
{
|
|
|
|
struct rt_schedulable_data *d = data;
|
|
|
|
struct task_group *child;
|
|
|
|
unsigned long total, sum = 0;
|
|
|
|
u64 period, runtime;
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
period = ktime_to_ns(tg->rt_bandwidth.rt_period);
|
|
|
|
runtime = tg->rt_bandwidth.rt_runtime;
|
2008-04-20 00:45:00 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
if (tg == d->tg) {
|
|
|
|
period = d->rt_period;
|
|
|
|
runtime = d->rt_runtime;
|
2008-04-20 00:45:00 +07:00
|
|
|
}
|
|
|
|
|
2008-09-23 20:33:44 +07:00
|
|
|
/*
|
|
|
|
* Cannot have more runtime than the period.
|
|
|
|
*/
|
|
|
|
if (runtime > period && runtime != RUNTIME_INF)
|
|
|
|
return -EINVAL;
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-09-23 20:33:44 +07:00
|
|
|
/*
|
|
|
|
* Ensure we don't starve existing RT tasks.
|
|
|
|
*/
|
2008-08-19 17:33:06 +07:00
|
|
|
if (rt_bandwidth_enabled() && !runtime && tg_has_rt_tasks(tg))
|
|
|
|
return -EBUSY;
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
total = to_ratio(period, runtime);
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-09-23 20:33:44 +07:00
|
|
|
/*
|
|
|
|
* Nobody can have more than the global setting allows.
|
|
|
|
*/
|
|
|
|
if (total > to_ratio(global_rt_period(), global_rt_runtime()))
|
|
|
|
return -EINVAL;
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-09-23 20:33:44 +07:00
|
|
|
/*
|
|
|
|
* The sum of our children's runtime should not exceed our own.
|
|
|
|
*/
|
2008-08-19 17:33:06 +07:00
|
|
|
list_for_each_entry_rcu(child, &tg->children, siblings) {
|
|
|
|
period = ktime_to_ns(child->rt_bandwidth.rt_period);
|
|
|
|
runtime = child->rt_bandwidth.rt_runtime;
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
if (child == d->tg) {
|
|
|
|
period = d->rt_period;
|
|
|
|
runtime = d->rt_runtime;
|
|
|
|
}
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
sum += to_ratio(period, runtime);
|
2008-02-13 21:45:39 +07:00
|
|
|
}
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
if (sum > total)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
2008-01-26 03:08:30 +07:00
|
|
|
}
|
|
|
|
|
2008-08-19 17:33:06 +07:00
|
|
|
static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
|
2008-02-28 16:51:56 +07:00
|
|
|
{
|
2008-08-19 17:33:06 +07:00
|
|
|
struct rt_schedulable_data data = {
|
|
|
|
.tg = tg,
|
|
|
|
.rt_period = period,
|
|
|
|
.rt_runtime = runtime,
|
|
|
|
};
|
|
|
|
|
|
|
|
return walk_tg_tree(tg_schedulable, tg_nop, &data);
|
2008-02-28 16:51:56 +07:00
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
static int tg_set_bandwidth(struct task_group *tg,
|
|
|
|
u64 rt_period, u64 rt_runtime)
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
2008-04-20 00:44:58 +07:00
|
|
|
int i, err = 0;
|
2008-02-13 21:45:39 +07:00
|
|
|
|
|
|
|
mutex_lock(&rt_constraints_mutex);
|
2008-02-28 16:51:56 +07:00
|
|
|
read_lock(&tasklist_lock);
|
2008-08-19 17:33:06 +07:00
|
|
|
err = __rt_schedulable(tg, rt_period, rt_runtime);
|
|
|
|
if (err)
|
2008-02-13 21:45:39 +07:00
|
|
|
goto unlock;
|
2008-04-20 00:44:58 +07:00
|
|
|
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
|
2008-04-20 00:44:57 +07:00
|
|
|
tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
|
|
|
|
tg->rt_bandwidth.rt_runtime = rt_runtime;
|
2008-04-20 00:44:58 +07:00
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
struct rt_rq *rt_rq = tg->rt_rq[i];
|
|
|
|
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock(&rt_rq->rt_runtime_lock);
|
2008-04-20 00:44:58 +07:00
|
|
|
rt_rq->rt_runtime = rt_runtime;
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_unlock(&rt_rq->rt_runtime_lock);
|
2008-04-20 00:44:58 +07:00
|
|
|
}
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
|
2008-02-13 21:45:39 +07:00
|
|
|
unlock:
|
2008-02-28 16:51:56 +07:00
|
|
|
read_unlock(&tasklist_lock);
|
2008-02-13 21:45:39 +07:00
|
|
|
mutex_unlock(&rt_constraints_mutex);
|
|
|
|
|
|
|
|
return err;
|
2008-01-26 03:08:30 +07:00
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
|
|
|
|
{
|
|
|
|
u64 rt_runtime, rt_period;
|
|
|
|
|
|
|
|
rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
|
|
|
|
rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
|
|
|
|
if (rt_runtime_us < 0)
|
|
|
|
rt_runtime = RUNTIME_INF;
|
|
|
|
|
|
|
|
return tg_set_bandwidth(tg, rt_period, rt_runtime);
|
|
|
|
}
|
|
|
|
|
2008-02-13 21:45:39 +07:00
|
|
|
long sched_group_rt_runtime(struct task_group *tg)
|
|
|
|
{
|
|
|
|
u64 rt_runtime_us;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
|
2008-02-13 21:45:39 +07:00
|
|
|
return -1;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
rt_runtime_us = tg->rt_bandwidth.rt_runtime;
|
2008-02-13 21:45:39 +07:00
|
|
|
do_div(rt_runtime_us, NSEC_PER_USEC);
|
|
|
|
return rt_runtime_us;
|
|
|
|
}
|
2008-04-20 00:44:57 +07:00
|
|
|
|
|
|
|
int sched_group_set_rt_period(struct task_group *tg, long rt_period_us)
|
|
|
|
{
|
|
|
|
u64 rt_runtime, rt_period;
|
|
|
|
|
|
|
|
rt_period = (u64)rt_period_us * NSEC_PER_USEC;
|
|
|
|
rt_runtime = tg->rt_bandwidth.rt_runtime;
|
|
|
|
|
2008-06-26 23:54:09 +07:00
|
|
|
if (rt_period == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
return tg_set_bandwidth(tg, rt_period, rt_runtime);
|
|
|
|
}
|
|
|
|
|
|
|
|
long sched_group_rt_period(struct task_group *tg)
|
|
|
|
{
|
|
|
|
u64 rt_period_us;
|
|
|
|
|
|
|
|
rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
|
|
|
|
do_div(rt_period_us, NSEC_PER_USEC);
|
|
|
|
return rt_period_us;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sched_rt_global_constraints(void)
|
|
|
|
{
|
2008-09-23 20:33:44 +07:00
|
|
|
u64 runtime, period;
|
2008-04-20 00:44:57 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
2008-09-11 07:00:19 +07:00
|
|
|
if (sysctl_sched_rt_period <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-09-23 20:33:44 +07:00
|
|
|
runtime = global_rt_runtime();
|
|
|
|
period = global_rt_period();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sanity check on the sysctl variables.
|
|
|
|
*/
|
|
|
|
if (runtime > period && runtime != RUNTIME_INF)
|
|
|
|
return -EINVAL;
|
2008-06-19 19:22:27 +07:00
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
mutex_lock(&rt_constraints_mutex);
|
2008-08-19 17:33:06 +07:00
|
|
|
read_lock(&tasklist_lock);
|
2008-09-23 20:33:44 +07:00
|
|
|
ret = __rt_schedulable(NULL, 0, 0);
|
2008-08-19 17:33:06 +07:00
|
|
|
read_unlock(&tasklist_lock);
|
2008-04-20 00:44:57 +07:00
|
|
|
mutex_unlock(&rt_constraints_mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2009-02-27 16:43:54 +07:00
|
|
|
|
|
|
|
int sched_rt_can_attach(struct task_group *tg, struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
/* Don't accept realtime tasks when there is no way for them to run */
|
|
|
|
if (rt_task(tsk) && tg->rt_bandwidth.rt_runtime == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-05-30 19:23:45 +07:00
|
|
|
#else /* !CONFIG_RT_GROUP_SCHED */
|
2008-04-20 00:44:57 +07:00
|
|
|
static int sched_rt_global_constraints(void)
|
|
|
|
{
|
2008-04-20 00:44:58 +07:00
|
|
|
unsigned long flags;
|
|
|
|
int i;
|
|
|
|
|
2008-09-11 07:00:19 +07:00
|
|
|
if (sysctl_sched_rt_period <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-05-05 22:50:21 +07:00
|
|
|
/*
|
|
|
|
* There's always some RT tasks in the root group
|
|
|
|
* -- migration, kstopmachine etc..
|
|
|
|
*/
|
|
|
|
if (sysctl_sched_rt_runtime == 0)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
|
2008-04-20 00:44:58 +07:00
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
struct rt_rq *rt_rq = &cpu_rq(i)->rt;
|
|
|
|
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_lock(&rt_rq->rt_runtime_lock);
|
2008-04-20 00:44:58 +07:00
|
|
|
rt_rq->rt_runtime = global_rt_runtime();
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_unlock(&rt_rq->rt_runtime_lock);
|
2008-04-20 00:44:58 +07:00
|
|
|
}
|
2009-11-17 21:32:06 +07:00
|
|
|
raw_spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
|
2008-04-20 00:44:58 +07:00
|
|
|
|
2008-04-20 00:44:57 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_RT_GROUP_SCHED */
|
2008-04-20 00:44:57 +07:00
|
|
|
|
|
|
|
int sched_rt_handler(struct ctl_table *table, int write,
|
2009-09-24 05:57:19 +07:00
|
|
|
void __user *buffer, size_t *lenp,
|
2008-04-20 00:44:57 +07:00
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int old_period, old_runtime;
|
|
|
|
static DEFINE_MUTEX(mutex);
|
|
|
|
|
|
|
|
mutex_lock(&mutex);
|
|
|
|
old_period = sysctl_sched_rt_period;
|
|
|
|
old_runtime = sysctl_sched_rt_runtime;
|
|
|
|
|
2009-09-24 05:57:19 +07:00
|
|
|
ret = proc_dointvec(table, write, buffer, lenp, ppos);
|
2008-04-20 00:44:57 +07:00
|
|
|
|
|
|
|
if (!ret && write) {
|
|
|
|
ret = sched_rt_global_constraints();
|
|
|
|
if (ret) {
|
|
|
|
sysctl_sched_rt_period = old_period;
|
|
|
|
sysctl_sched_rt_runtime = old_runtime;
|
|
|
|
} else {
|
|
|
|
def_rt_bandwidth.rt_runtime = global_rt_runtime();
|
|
|
|
def_rt_bandwidth.rt_period =
|
|
|
|
ns_to_ktime(global_rt_period());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2007-10-19 13:41:03 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
2007-10-19 13:41:03 +07:00
|
|
|
|
|
|
|
/* return corresponding task_group object of a cgroup */
|
2007-10-24 23:23:50 +07:00
|
|
|
static inline struct task_group *cgroup_tg(struct cgroup *cgrp)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
2007-10-24 23:23:50 +07:00
|
|
|
return container_of(cgroup_subsys_state(cgrp, cpu_cgroup_subsys_id),
|
|
|
|
struct task_group, css);
|
2007-10-19 13:41:03 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct cgroup_subsys_state *
|
2007-10-24 23:23:50 +07:00
|
|
|
cpu_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
2008-04-20 00:44:59 +07:00
|
|
|
struct task_group *tg, *parent;
|
2007-10-19 13:41:03 +07:00
|
|
|
|
2007-10-24 23:23:50 +07:00
|
|
|
if (!cgrp->parent) {
|
2007-10-19 13:41:03 +07:00
|
|
|
/* This is early initialization for the top cgroup */
|
|
|
|
return &init_task_group.css;
|
|
|
|
}
|
|
|
|
|
2008-04-20 00:44:59 +07:00
|
|
|
parent = cgroup_tg(cgrp->parent);
|
|
|
|
tg = sched_create_group(parent);
|
2007-10-19 13:41:03 +07:00
|
|
|
if (IS_ERR(tg))
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
return &tg->css;
|
|
|
|
}
|
|
|
|
|
2007-12-05 21:46:09 +07:00
|
|
|
static void
|
|
|
|
cpu_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
2007-10-24 23:23:50 +07:00
|
|
|
struct task_group *tg = cgroup_tg(cgrp);
|
2007-10-19 13:41:03 +07:00
|
|
|
|
|
|
|
sched_destroy_group(tg);
|
|
|
|
}
|
|
|
|
|
2007-12-05 21:46:09 +07:00
|
|
|
static int
|
2009-09-24 05:56:31 +07:00
|
|
|
cpu_cgroup_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2009-02-27 16:43:54 +07:00
|
|
|
if (!sched_rt_can_attach(cgroup_tg(cgrp), tsk))
|
2008-02-13 21:45:40 +07:00
|
|
|
return -EINVAL;
|
|
|
|
#else
|
2007-10-19 13:41:03 +07:00
|
|
|
/* We don't support RT-tasks being in separate groups */
|
|
|
|
if (tsk->sched_class != &fair_sched_class)
|
|
|
|
return -EINVAL;
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
2009-09-24 05:56:31 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2007-10-19 13:41:03 +07:00
|
|
|
|
2009-09-24 05:56:31 +07:00
|
|
|
static int
|
|
|
|
cpu_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,
|
|
|
|
struct task_struct *tsk, bool threadgroup)
|
|
|
|
{
|
|
|
|
int retval = cpu_cgroup_can_attach_task(cgrp, tsk);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
if (threadgroup) {
|
|
|
|
struct task_struct *c;
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(c, &tsk->thread_group, thread_group) {
|
|
|
|
retval = cpu_cgroup_can_attach_task(cgrp, c);
|
|
|
|
if (retval) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2007-10-19 13:41:03 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-10-24 23:23:50 +07:00
|
|
|
cpu_cgroup_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,
|
2009-09-24 05:56:31 +07:00
|
|
|
struct cgroup *old_cont, struct task_struct *tsk,
|
|
|
|
bool threadgroup)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
|
|
|
sched_move_task(tsk);
|
2009-09-24 05:56:31 +07:00
|
|
|
if (threadgroup) {
|
|
|
|
struct task_struct *c;
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(c, &tsk->thread_group, thread_group) {
|
|
|
|
sched_move_task(c);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2007-10-19 13:41:03 +07:00
|
|
|
}
|
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2008-04-29 14:59:56 +07:00
|
|
|
static int cpu_shares_write_u64(struct cgroup *cgrp, struct cftype *cftype,
|
2007-10-24 23:23:50 +07:00
|
|
|
u64 shareval)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
2007-10-24 23:23:50 +07:00
|
|
|
return sched_group_set_shares(cgroup_tg(cgrp), shareval);
|
2007-10-19 13:41:03 +07:00
|
|
|
}
|
|
|
|
|
2008-04-29 14:59:56 +07:00
|
|
|
static u64 cpu_shares_read_u64(struct cgroup *cgrp, struct cftype *cft)
|
2007-10-19 13:41:03 +07:00
|
|
|
{
|
2007-10-24 23:23:50 +07:00
|
|
|
struct task_group *tg = cgroup_tg(cgrp);
|
2007-10-19 13:41:03 +07:00
|
|
|
|
|
|
|
return (u64) tg->shares;
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
2007-10-19 13:41:03 +07:00
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-05-15 06:05:46 +07:00
|
|
|
static int cpu_rt_runtime_write(struct cgroup *cgrp, struct cftype *cft,
|
2008-04-29 15:00:06 +07:00
|
|
|
s64 val)
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
2008-04-29 15:00:06 +07:00
|
|
|
return sched_group_set_rt_runtime(cgroup_tg(cgrp), val);
|
2008-01-26 03:08:30 +07:00
|
|
|
}
|
|
|
|
|
2008-04-29 15:00:06 +07:00
|
|
|
static s64 cpu_rt_runtime_read(struct cgroup *cgrp, struct cftype *cft)
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
2008-04-29 15:00:06 +07:00
|
|
|
return sched_group_rt_runtime(cgroup_tg(cgrp));
|
2008-01-26 03:08:30 +07:00
|
|
|
}
|
2008-04-20 00:44:57 +07:00
|
|
|
|
|
|
|
static int cpu_rt_period_write_uint(struct cgroup *cgrp, struct cftype *cftype,
|
|
|
|
u64 rt_period_us)
|
|
|
|
{
|
|
|
|
return sched_group_set_rt_period(cgroup_tg(cgrp), rt_period_us);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 cpu_rt_period_read_uint(struct cgroup *cgrp, struct cftype *cft)
|
|
|
|
{
|
|
|
|
return sched_group_rt_period(cgroup_tg(cgrp));
|
|
|
|
}
|
2008-05-30 19:23:45 +07:00
|
|
|
#endif /* CONFIG_RT_GROUP_SCHED */
|
2008-01-26 03:08:30 +07:00
|
|
|
|
2007-10-30 03:18:11 +07:00
|
|
|
static struct cftype cpu_files[] = {
|
2008-02-13 21:45:40 +07:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2007-10-30 03:18:11 +07:00
|
|
|
{
|
|
|
|
.name = "shares",
|
2008-04-29 14:59:56 +07:00
|
|
|
.read_u64 = cpu_shares_read_u64,
|
|
|
|
.write_u64 = cpu_shares_write_u64,
|
2007-10-30 03:18:11 +07:00
|
|
|
},
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
2008-01-26 03:08:30 +07:00
|
|
|
{
|
2008-02-13 21:45:39 +07:00
|
|
|
.name = "rt_runtime_us",
|
2008-04-29 15:00:06 +07:00
|
|
|
.read_s64 = cpu_rt_runtime_read,
|
|
|
|
.write_s64 = cpu_rt_runtime_write,
|
2008-01-26 03:08:30 +07:00
|
|
|
},
|
2008-04-20 00:44:57 +07:00
|
|
|
{
|
|
|
|
.name = "rt_period_us",
|
2008-04-29 14:59:56 +07:00
|
|
|
.read_u64 = cpu_rt_period_read_uint,
|
|
|
|
.write_u64 = cpu_rt_period_write_uint,
|
2008-04-20 00:44:57 +07:00
|
|
|
},
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif
|
2007-10-19 13:41:03 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int cpu_cgroup_populate(struct cgroup_subsys *ss, struct cgroup *cont)
|
|
|
|
{
|
2007-10-30 03:18:11 +07:00
|
|
|
return cgroup_add_files(cont, ss, cpu_files, ARRAY_SIZE(cpu_files));
|
2007-10-19 13:41:03 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
struct cgroup_subsys cpu_cgroup_subsys = {
|
2007-10-30 03:18:11 +07:00
|
|
|
.name = "cpu",
|
|
|
|
.create = cpu_cgroup_create,
|
|
|
|
.destroy = cpu_cgroup_destroy,
|
|
|
|
.can_attach = cpu_cgroup_can_attach,
|
|
|
|
.attach = cpu_cgroup_attach,
|
|
|
|
.populate = cpu_cgroup_populate,
|
|
|
|
.subsys_id = cpu_cgroup_subsys_id,
|
2007-10-19 13:41:03 +07:00
|
|
|
.early_init = 1,
|
|
|
|
};
|
|
|
|
|
2008-02-13 21:45:40 +07:00
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
2007-12-03 02:04:49 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_CGROUP_CPUACCT
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CPU accounting code for task groups.
|
|
|
|
*
|
|
|
|
* Based on the work by Paul Menage (menage@google.com) and Balbir Singh
|
|
|
|
* (balbir@in.ibm.com).
|
|
|
|
*/
|
|
|
|
|
2008-11-10 22:11:13 +07:00
|
|
|
/* track cpu usage of a group of tasks and its child groups */
|
2007-12-03 02:04:49 +07:00
|
|
|
struct cpuacct {
|
|
|
|
struct cgroup_subsys_state css;
|
|
|
|
/* cpuusage holds pointer to a u64-type object on every cpu */
|
2010-02-02 12:38:57 +07:00
|
|
|
u64 __percpu *cpuusage;
|
2009-03-31 11:32:22 +07:00
|
|
|
struct percpu_counter cpustat[CPUACCT_STAT_NSTATS];
|
2008-11-10 22:11:13 +07:00
|
|
|
struct cpuacct *parent;
|
2007-12-03 02:04:49 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct cgroup_subsys cpuacct_subsys;
|
|
|
|
|
|
|
|
/* return cpu accounting group corresponding to this container */
|
2008-02-29 11:32:43 +07:00
|
|
|
static inline struct cpuacct *cgroup_ca(struct cgroup *cgrp)
|
2007-12-03 02:04:49 +07:00
|
|
|
{
|
2008-02-29 11:32:43 +07:00
|
|
|
return container_of(cgroup_subsys_state(cgrp, cpuacct_subsys_id),
|
2007-12-03 02:04:49 +07:00
|
|
|
struct cpuacct, css);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return cpu accounting group to which this task belongs */
|
|
|
|
static inline struct cpuacct *task_ca(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
return container_of(task_subsys_state(tsk, cpuacct_subsys_id),
|
|
|
|
struct cpuacct, css);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create a new cpu accounting group */
|
|
|
|
static struct cgroup_subsys_state *cpuacct_create(
|
2008-02-29 11:32:43 +07:00
|
|
|
struct cgroup_subsys *ss, struct cgroup *cgrp)
|
2007-12-03 02:04:49 +07:00
|
|
|
{
|
|
|
|
struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
|
2009-03-31 11:32:22 +07:00
|
|
|
int i;
|
2007-12-03 02:04:49 +07:00
|
|
|
|
|
|
|
if (!ca)
|
2009-03-31 11:32:22 +07:00
|
|
|
goto out;
|
2007-12-03 02:04:49 +07:00
|
|
|
|
|
|
|
ca->cpuusage = alloc_percpu(u64);
|
2009-03-31 11:32:22 +07:00
|
|
|
if (!ca->cpuusage)
|
|
|
|
goto out_free_ca;
|
|
|
|
|
|
|
|
for (i = 0; i < CPUACCT_STAT_NSTATS; i++)
|
|
|
|
if (percpu_counter_init(&ca->cpustat[i], 0))
|
|
|
|
goto out_free_counters;
|
2007-12-03 02:04:49 +07:00
|
|
|
|
2008-11-10 22:11:13 +07:00
|
|
|
if (cgrp->parent)
|
|
|
|
ca->parent = cgroup_ca(cgrp->parent);
|
|
|
|
|
2007-12-03 02:04:49 +07:00
|
|
|
return &ca->css;
|
2009-03-31 11:32:22 +07:00
|
|
|
|
|
|
|
out_free_counters:
|
|
|
|
while (--i >= 0)
|
|
|
|
percpu_counter_destroy(&ca->cpustat[i]);
|
|
|
|
free_percpu(ca->cpuusage);
|
|
|
|
out_free_ca:
|
|
|
|
kfree(ca);
|
|
|
|
out:
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2007-12-03 02:04:49 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* destroy an existing cpu accounting group */
|
2007-12-05 21:46:09 +07:00
|
|
|
static void
|
2008-02-29 11:32:43 +07:00
|
|
|
cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
|
2007-12-03 02:04:49 +07:00
|
|
|
{
|
2008-02-29 11:32:43 +07:00
|
|
|
struct cpuacct *ca = cgroup_ca(cgrp);
|
2009-03-31 11:32:22 +07:00
|
|
|
int i;
|
2007-12-03 02:04:49 +07:00
|
|
|
|
2009-03-31 11:32:22 +07:00
|
|
|
for (i = 0; i < CPUACCT_STAT_NSTATS; i++)
|
|
|
|
percpu_counter_destroy(&ca->cpustat[i]);
|
2007-12-03 02:04:49 +07:00
|
|
|
free_percpu(ca->cpuusage);
|
|
|
|
kfree(ca);
|
|
|
|
}
|
|
|
|
|
2008-12-16 13:02:01 +07:00
|
|
|
static u64 cpuacct_cpuusage_read(struct cpuacct *ca, int cpu)
|
|
|
|
{
|
2009-02-20 14:29:08 +07:00
|
|
|
u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
|
2008-12-16 13:02:01 +07:00
|
|
|
u64 data;
|
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
/*
|
|
|
|
* Take rq->lock to make 64-bit read safe on 32-bit platforms.
|
|
|
|
*/
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irq(&cpu_rq(cpu)->lock);
|
2008-12-16 13:02:01 +07:00
|
|
|
data = *cpuusage;
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
|
2008-12-16 13:02:01 +07:00
|
|
|
#else
|
|
|
|
data = *cpuusage;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cpuacct_cpuusage_write(struct cpuacct *ca, int cpu, u64 val)
|
|
|
|
{
|
2009-02-20 14:29:08 +07:00
|
|
|
u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
|
2008-12-16 13:02:01 +07:00
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
/*
|
|
|
|
* Take rq->lock to make 64-bit write safe on 32-bit platforms.
|
|
|
|
*/
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_lock_irq(&cpu_rq(cpu)->lock);
|
2008-12-16 13:02:01 +07:00
|
|
|
*cpuusage = val;
|
2009-11-17 20:28:38 +07:00
|
|
|
raw_spin_unlock_irq(&cpu_rq(cpu)->lock);
|
2008-12-16 13:02:01 +07:00
|
|
|
#else
|
|
|
|
*cpuusage = val;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-12-03 02:04:49 +07:00
|
|
|
/* return total cpu usage (in nanoseconds) of a group */
|
2008-02-29 11:32:43 +07:00
|
|
|
static u64 cpuusage_read(struct cgroup *cgrp, struct cftype *cft)
|
2007-12-03 02:04:49 +07:00
|
|
|
{
|
2008-02-29 11:32:43 +07:00
|
|
|
struct cpuacct *ca = cgroup_ca(cgrp);
|
2007-12-03 02:04:49 +07:00
|
|
|
u64 totalcpuusage = 0;
|
|
|
|
int i;
|
|
|
|
|
2008-12-16 13:02:01 +07:00
|
|
|
for_each_present_cpu(i)
|
|
|
|
totalcpuusage += cpuacct_cpuusage_read(ca, i);
|
2007-12-03 02:04:49 +07:00
|
|
|
|
|
|
|
return totalcpuusage;
|
|
|
|
}
|
|
|
|
|
2008-02-29 11:32:44 +07:00
|
|
|
static int cpuusage_write(struct cgroup *cgrp, struct cftype *cftype,
|
|
|
|
u64 reset)
|
|
|
|
{
|
|
|
|
struct cpuacct *ca = cgroup_ca(cgrp);
|
|
|
|
int err = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (reset) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-12-16 13:02:01 +07:00
|
|
|
for_each_present_cpu(i)
|
|
|
|
cpuacct_cpuusage_write(ca, i, 0);
|
2008-02-29 11:32:44 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-12-16 13:04:15 +07:00
|
|
|
static int cpuacct_percpu_seq_read(struct cgroup *cgroup, struct cftype *cft,
|
|
|
|
struct seq_file *m)
|
|
|
|
{
|
|
|
|
struct cpuacct *ca = cgroup_ca(cgroup);
|
|
|
|
u64 percpu;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_present_cpu(i) {
|
|
|
|
percpu = cpuacct_cpuusage_read(ca, i);
|
|
|
|
seq_printf(m, "%llu ", (unsigned long long) percpu);
|
|
|
|
}
|
|
|
|
seq_printf(m, "\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-31 11:32:22 +07:00
|
|
|
static const char *cpuacct_stat_desc[] = {
|
|
|
|
[CPUACCT_STAT_USER] = "user",
|
|
|
|
[CPUACCT_STAT_SYSTEM] = "system",
|
|
|
|
};
|
|
|
|
|
|
|
|
static int cpuacct_stats_show(struct cgroup *cgrp, struct cftype *cft,
|
|
|
|
struct cgroup_map_cb *cb)
|
|
|
|
{
|
|
|
|
struct cpuacct *ca = cgroup_ca(cgrp);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < CPUACCT_STAT_NSTATS; i++) {
|
|
|
|
s64 val = percpu_counter_read(&ca->cpustat[i]);
|
|
|
|
val = cputime64_to_clock_t(val);
|
|
|
|
cb->fill(cb, cpuacct_stat_desc[i], val);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-03 02:04:49 +07:00
|
|
|
static struct cftype files[] = {
|
|
|
|
{
|
|
|
|
.name = "usage",
|
2008-04-29 14:59:56 +07:00
|
|
|
.read_u64 = cpuusage_read,
|
|
|
|
.write_u64 = cpuusage_write,
|
2007-12-03 02:04:49 +07:00
|
|
|
},
|
2008-12-16 13:04:15 +07:00
|
|
|
{
|
|
|
|
.name = "usage_percpu",
|
|
|
|
.read_seq_string = cpuacct_percpu_seq_read,
|
|
|
|
},
|
2009-03-31 11:32:22 +07:00
|
|
|
{
|
|
|
|
.name = "stat",
|
|
|
|
.read_map = cpuacct_stats_show,
|
|
|
|
},
|
2007-12-03 02:04:49 +07:00
|
|
|
};
|
|
|
|
|
2008-02-29 11:32:43 +07:00
|
|
|
static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
|
2007-12-03 02:04:49 +07:00
|
|
|
{
|
2008-02-29 11:32:43 +07:00
|
|
|
return cgroup_add_files(cgrp, ss, files, ARRAY_SIZE(files));
|
2007-12-03 02:04:49 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* charge this task's execution time to its accounting group.
|
|
|
|
*
|
|
|
|
* called with rq->lock held.
|
|
|
|
*/
|
|
|
|
static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
|
|
|
|
{
|
|
|
|
struct cpuacct *ca;
|
2008-11-10 22:11:13 +07:00
|
|
|
int cpu;
|
2007-12-03 02:04:49 +07:00
|
|
|
|
2009-02-26 14:40:15 +07:00
|
|
|
if (unlikely(!cpuacct_subsys.active))
|
2007-12-03 02:04:49 +07:00
|
|
|
return;
|
|
|
|
|
2008-11-10 22:11:13 +07:00
|
|
|
cpu = task_cpu(tsk);
|
2009-03-23 11:32:53 +07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2007-12-03 02:04:49 +07:00
|
|
|
ca = task_ca(tsk);
|
|
|
|
|
2008-11-10 22:11:13 +07:00
|
|
|
for (; ca; ca = ca->parent) {
|
2009-02-20 14:29:08 +07:00
|
|
|
u64 *cpuusage = per_cpu_ptr(ca->cpuusage, cpu);
|
2007-12-03 02:04:49 +07:00
|
|
|
*cpuusage += cputime;
|
|
|
|
}
|
2009-03-23 11:32:53 +07:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
2007-12-03 02:04:49 +07:00
|
|
|
}
|
|
|
|
|
2010-02-03 05:46:13 +07:00
|
|
|
/*
|
|
|
|
* When CONFIG_VIRT_CPU_ACCOUNTING is enabled one jiffy can be very large
|
|
|
|
* in cputime_t units. As a result, cpuacct_update_stats calls
|
|
|
|
* percpu_counter_add with values large enough to always overflow the
|
|
|
|
* per cpu batch limit causing bad SMP scalability.
|
|
|
|
*
|
|
|
|
* To fix this we scale percpu_counter_batch by cputime_one_jiffy so we
|
|
|
|
* batch the same amount of time with CONFIG_VIRT_CPU_ACCOUNTING disabled
|
|
|
|
* and enabled. We cap it at INT_MAX which is the largest allowed batch value.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
#define CPUACCT_BATCH \
|
|
|
|
min_t(long, percpu_counter_batch * cputime_one_jiffy, INT_MAX)
|
|
|
|
#else
|
|
|
|
#define CPUACCT_BATCH 0
|
|
|
|
#endif
|
|
|
|
|
2009-03-31 11:32:22 +07:00
|
|
|
/*
|
|
|
|
* Charge the system/user time to the task's accounting group.
|
|
|
|
*/
|
|
|
|
static void cpuacct_update_stats(struct task_struct *tsk,
|
|
|
|
enum cpuacct_stat_index idx, cputime_t val)
|
|
|
|
{
|
|
|
|
struct cpuacct *ca;
|
2010-02-03 05:46:13 +07:00
|
|
|
int batch = CPUACCT_BATCH;
|
2009-03-31 11:32:22 +07:00
|
|
|
|
|
|
|
if (unlikely(!cpuacct_subsys.active))
|
|
|
|
return;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
ca = task_ca(tsk);
|
|
|
|
|
|
|
|
do {
|
2010-02-03 05:46:13 +07:00
|
|
|
__percpu_counter_add(&ca->cpustat[idx], val, batch);
|
2009-03-31 11:32:22 +07:00
|
|
|
ca = ca->parent;
|
|
|
|
} while (ca);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2007-12-03 02:04:49 +07:00
|
|
|
struct cgroup_subsys cpuacct_subsys = {
|
|
|
|
.name = "cpuacct",
|
|
|
|
.create = cpuacct_create,
|
|
|
|
.destroy = cpuacct_destroy,
|
|
|
|
.populate = cpuacct_populate,
|
|
|
|
.subsys_id = cpuacct_subsys_id,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_CGROUP_CPUACCT */
|
2009-06-25 23:08:16 +07:00
|
|
|
|
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
|
|
|
|
void synchronize_sched_expedited(void)
|
|
|
|
{
|
2010-05-07 01:42:52 +07:00
|
|
|
barrier();
|
2009-06-25 23:08:16 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(synchronize_sched_expedited);
|
|
|
|
|
|
|
|
#else /* #ifndef CONFIG_SMP */
|
|
|
|
|
2010-05-06 23:49:21 +07:00
|
|
|
static atomic_t synchronize_sched_expedited_count = ATOMIC_INIT(0);
|
2009-06-25 23:08:16 +07:00
|
|
|
|
2010-05-06 23:49:21 +07:00
|
|
|
static int synchronize_sched_expedited_cpu_stop(void *data)
|
2009-06-25 23:08:16 +07:00
|
|
|
{
|
2010-05-06 23:49:21 +07:00
|
|
|
/*
|
|
|
|
* There must be a full memory barrier on each affected CPU
|
|
|
|
* between the time that try_stop_cpus() is called and the
|
|
|
|
* time that it returns.
|
|
|
|
*
|
|
|
|
* In the current initial implementation of cpu_stop, the
|
|
|
|
* above condition is already met when the control reaches
|
|
|
|
* this point and the following smp_mb() is not strictly
|
|
|
|
* necessary. Do smp_mb() anyway for documentation and
|
|
|
|
* robustness against future implementation changes.
|
|
|
|
*/
|
2010-05-06 23:49:21 +07:00
|
|
|
smp_mb(); /* See above comment block. */
|
2010-05-06 23:49:21 +07:00
|
|
|
return 0;
|
2009-06-25 23:08:16 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for an rcu-sched grace period to elapse, but use "big hammer"
|
|
|
|
* approach to force grace period to end quickly. This consumes
|
|
|
|
* significant time on all CPUs, and is thus not recommended for
|
|
|
|
* any sort of common-case code.
|
|
|
|
*
|
|
|
|
* Note that it is illegal to call this function while holding any
|
|
|
|
* lock that is acquired by a CPU-hotplug notifier. Failing to
|
|
|
|
* observe this restriction will result in deadlock.
|
|
|
|
*/
|
|
|
|
void synchronize_sched_expedited(void)
|
|
|
|
{
|
2010-05-06 23:49:21 +07:00
|
|
|
int snap, trycount = 0;
|
2009-06-25 23:08:16 +07:00
|
|
|
|
|
|
|
smp_mb(); /* ensure prior mod happens before capturing snap. */
|
2010-05-06 23:49:21 +07:00
|
|
|
snap = atomic_read(&synchronize_sched_expedited_count) + 1;
|
2009-06-25 23:08:16 +07:00
|
|
|
get_online_cpus();
|
2010-05-06 23:49:21 +07:00
|
|
|
while (try_stop_cpus(cpu_online_mask,
|
|
|
|
synchronize_sched_expedited_cpu_stop,
|
2010-05-06 23:49:21 +07:00
|
|
|
NULL) == -EAGAIN) {
|
2009-06-25 23:08:16 +07:00
|
|
|
put_online_cpus();
|
|
|
|
if (trycount++ < 10)
|
|
|
|
udelay(trycount * num_online_cpus());
|
|
|
|
else {
|
|
|
|
synchronize_sched();
|
|
|
|
return;
|
|
|
|
}
|
2010-05-06 23:49:21 +07:00
|
|
|
if (atomic_read(&synchronize_sched_expedited_count) - snap > 0) {
|
2009-06-25 23:08:16 +07:00
|
|
|
smp_mb(); /* ensure test happens before caller kfree */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
get_online_cpus();
|
|
|
|
}
|
2010-05-06 23:49:21 +07:00
|
|
|
atomic_inc(&synchronize_sched_expedited_count);
|
2010-05-06 23:49:21 +07:00
|
|
|
smp_mb__after_atomic_inc(); /* ensure post-GP actions seen after GP. */
|
2009-06-25 23:08:16 +07:00
|
|
|
put_online_cpus();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(synchronize_sched_expedited);
|
|
|
|
|
|
|
|
#endif /* #else #ifndef CONFIG_SMP */
|