iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sched/fair: Clean up the explanation around decaying load update misses

Browse Source 
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Peter Zijlstra 2015-10-19 13:49:30 +02:00 committed by Ingo Molnar
parent 69e51e92a3
commit d937cdc59e
1 changed files with 24 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
kernel/sched/fair.c
View File

@ -4222,42 +4222,37 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
*/ */
/* /*
* The exact cpuload at various idx values, calculated at every tick would be * The exact cpuload calculated at every tick would be:
* load = (2^idx - 1) / 2^idx * load + 1 / 2^idx * cur_load
* *
* If a cpu misses updates for n-1 ticks (as it was idle) and update gets called * load' = (1 - 1/2^i) * load + (1/2^i) * cur_load
* on nth tick when cpu may be busy, then we have: *
* load = ((2^idx - 1) / 2^idx)^(n-1) * load * If a cpu misses updates for n ticks (as it was idle) and update gets
* load = (2^idx - 1) / 2^idx) * load + 1 / 2^idx * cur_load * called on the n+1-th tick when cpu may be busy, then we have:
*
* load_n = (1 - 1/2^i)^n * load_0
* load_n+1 = (1 - 1/2^i) * load_n + (1/2^i) * cur_load
* *
* decay_load_missed() below does efficient calculation of * decay_load_missed() below does efficient calculation of
* load = ((2^idx - 1) / 2^idx)^(n-1) * load *
* avoiding 0..n-1 loop doing load = ((2^idx - 1) / 2^idx) * load * load' = (1 - 1/2^i)^n * load
*
* Because x^(n+m) := x^n * x^m we can decompose any x^n in power-of-2 factors.
* This allows us to precompute the above in said factors, thereby allowing the
* reduction of an arbitrary n in O(log_2 n) steps. (See also
* fixed_power_int())
* *
* The calculation is approximated on a 128 point scale. * The calculation is approximated on a 128 point scale.
* degrade_zero_ticks is the number of ticks after which load at any
* particular idx is approximated to be zero.
* degrade_factor is a precomputed table, a row for each load idx.
* Each column corresponds to degradation factor for a power of two ticks,
* based on 128 point scale.
* Example:
* row 2, col 3 (=12) says that the degradation at load idx 2 after
* 8 ticks is 12/128 (which is an approximation of exact factor 3^8/4^8).
*
* With this power of 2 load factors, we can degrade the load n times
* by looking at 1 bits in n and doing as many mult/shift instead of
* n mult/shifts needed by the exact degradation.
*/ */
#define DEGRADE_SHIFT 7 #define DEGRADE_SHIFT 7
static const unsigned char
degrade_zero_ticks[CPU_LOAD_IDX_MAX] = {0, 8, 32, 64, 128}; static const u8 degrade_zero_ticks[CPU_LOAD_IDX_MAX] = {0, 8, 32, 64, 128};
static const unsigned char static const u8 degrade_factor[CPU_LOAD_IDX_MAX][DEGRADE_SHIFT + 1] = {
degrade_factor[CPU_LOAD_IDX_MAX][DEGRADE_SHIFT + 1] = { { 0, 0, 0, 0, 0, 0, 0, 0 },
{0, 0, 0, 0, 0, 0, 0, 0}, { 64, 32, 8, 0, 0, 0, 0, 0 },
{64, 32, 8, 0, 0, 0, 0, 0}, { 96, 72, 40, 12, 1, 0, 0, 0 },
{96, 72, 40, 12, 1, 0, 0}, { 112, 98, 75, 43, 15, 1, 0, 0 },
{112, 98, 75, 43, 15, 1, 0}, { 120, 112, 98, 76, 45, 16, 2, 0 }
{120, 112, 98, 76, 45, 16, 2} }; };
/* /*
* Update cpu_load for any missed ticks, due to tickless idle. The backlog * Update cpu_load for any missed ticks, due to tickless idle. The backlog