1 files changed, 133 insertions, 0 deletions

diff --git a/recipes-kernel/linux/linux-ti33x-psp-3.2/3.2.17/0130-sched-Fix-nohz-load-accounting-again.patch b/recipes-kernel/linux/linux-ti33x-psp-3.2/3.2.17/0130-sched-Fix-nohz-load-accounting-again.patch
new file mode 100644
index 00000000..44a254b9
--- /dev/null
+++ b/recipes-kernel/linux/linux-ti33x-psp-3.2/3.2.17/0130-sched-Fix-nohz-load-accounting-again.patch
@@ -0,0 +1,133 @@
+From 01347c8bd017f3c031bc472db23953f9695fd65c Mon Sep 17 00:00:00 2001
+From: Peter Zijlstra <peterz@infradead.org>
+Date: Thu, 1 Mar 2012 15:04:46 +0100
+Subject: [PATCH 130/165] sched: Fix nohz load accounting -- again!
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+commit c308b56b5398779cd3da0f62ab26b0453494c3d4 upstream.
+
+Various people reported nohz load tracking still being wrecked, but Doug
+spotted the actual problem. We fold the nohz remainder in too soon,
+causing us to loose samples and under-account.
+
+So instead of playing catch-up up-front, always do a single load-fold
+with whatever state we encounter and only then fold the nohz remainder
+and play catch-up.
+
+Reported-by: Doug Smythies <dsmythies@telus.net>
+Reported-by: LesÅ=82aw Kope=C4=87 <leslaw.kopec@nasza-klasa.pl>
+Reported-by: Aman Gupta <aman@tmm1.net>
+Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
+Link: http://lkml.kernel.org/n/tip-4v31etnhgg9kwd6ocgx3rxl8@git.kernel.org
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+[bwh: Backported to 3.2: change filename]
+Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
+---
+ kernel/sched.c |   53 ++++++++++++++++++++++++++---------------------------
+ 1 files changed, 26 insertions(+), 27 deletions(-)
+
+diff --git a/kernel/sched.c b/kernel/sched.c
+index 106a3b8..299f55c 100644
+--- a/kernel/sched.c
++++ b/kernel/sched.c
+@@ -3538,13 +3538,10 @@ calc_load_n(unsigned long load, unsigned long exp,
+  * Once we've updated the global active value, we need to apply the exponential
+  * weights adjusted to the number of cycles missed.
+  */
+-static void calc_global_nohz(unsigned long ticks)
++static void calc_global_nohz(void)
+ {
+        long delta, active, n;
+ 
+-       if (time_before(jiffies, calc_load_update))
+-               return;
+-
+        /*
+         * If we crossed a calc_load_update boundary, make sure to fold
+         * any pending idle changes, the respective CPUs might have
+@@ -3556,31 +3553,25 @@ static void calc_global_nohz(unsigned long ticks)
+                atomic_long_add(delta, &calc_load_tasks);
+ 
+        /*
+-        * If we were idle for multiple load cycles, apply them.
++        * It could be the one fold was all it took, we done!
+         */
+-       if (ticks >= LOAD_FREQ) {
+-               n = ticks / LOAD_FREQ;
++       if (time_before(jiffies, calc_load_update + 10))
++               return;
+ 
+-               active = atomic_long_read(&calc_load_tasks);
+-               active = active > 0 ? active * FIXED_1 : 0;
++       /*
++        * Catch-up, fold however many we are behind still
++        */
++       delta = jiffies - calc_load_update - 10;
++       n = 1 + (delta / LOAD_FREQ);
+ 
+-               avenrun[0] = calc_load_n(avenrun[0], EXP_1, active, n);
+-               avenrun[1] = calc_load_n(avenrun[1], EXP_5, active, n);
+-               avenrun[2] = calc_load_n(avenrun[2], EXP_15, active, n);
++       active = atomic_long_read(&calc_load_tasks);
++       active = active > 0 ? active * FIXED_1 : 0;
+ 
+-               calc_load_update += n * LOAD_FREQ;
+-       }
++       avenrun[0] = calc_load_n(avenrun[0], EXP_1, active, n);
++       avenrun[1] = calc_load_n(avenrun[1], EXP_5, active, n);
++       avenrun[2] = calc_load_n(avenrun[2], EXP_15, active, n);
+ 
+-       /*
+-        * Its possible the remainder of the above division also crosses
+-        * a LOAD_FREQ period, the regular check in calc_global_load()
+-        * which comes after this will take care of that.
+-        *
+-        * Consider us being 11 ticks before a cycle completion, and us
+-        * sleeping for 4*LOAD_FREQ + 22 ticks, then the above code will
+-        * age us 4 cycles, and the test in calc_global_load() will
+-        * pick up the final one.
+-        */
++       calc_load_update += n * LOAD_FREQ;
+ }
+ #else
+ static void calc_load_account_idle(struct rq *this_rq)
+@@ -3592,7 +3583,7 @@ static inline long calc_load_fold_idle(void)
+        return 0;
+ }
+ 
+-static void calc_global_nohz(unsigned long ticks)
++static void calc_global_nohz(void)
+ {
+ }
+ #endif
+@@ -3620,8 +3611,6 @@ void calc_global_load(unsigned long ticks)
+ {
+        long active;
+ 
+-       calc_global_nohz(ticks);
+-
+        if (time_before(jiffies, calc_load_update + 10))
+                return;
+ 
+@@ -3633,6 +3622,16 @@ void calc_global_load(unsigned long ticks)
+        avenrun[2] = calc_load(avenrun[2], EXP_15, active);
+ 
+        calc_load_update += LOAD_FREQ;
++
++       /*
++        * Account one period with whatever state we found before
++        * folding in the nohz state and ageing the entire idle period.
++        *
++        * This avoids loosing a sample when we go idle between 
++        * calc_load_account_active() (10 ticks ago) and now and thus
++        * under-accounting.
++        */
++       calc_global_nohz();
+ }
+ 
+ /*
+-- 
+1.7.7.6
+