sched/fair: Fix FTQ noise bench regression

A regression of the FTQ noise has been reported by Ying Huang,
on the following hardware:

  8 threads Intel(R) Core(TM)i7-4770 CPU @ 3.40GHz with 8G memory

... which was caused by this commit:

  commit 4e5160766fcc ("sched/fair: Propagate asynchrous detach")

The only part of the patch that can increase the noise is the update
of blocked load of group entity in update_blocked_averages().

We can optimize this call and skip the update of group entity if its load
and utilization are already null and there is no pending propagation of load
in the task group.

This optimization partly restores the noise score. A more agressive
optimization has been tried but has shown worse score.

Reported-by: ying.huang@linux.intel.com
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
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>
Cc: dietmar.eggemann@arm.com
Cc: ying.huang@intel.com
Fixes: 4e5160766fcc ("sched/fair: Propagate asynchrous detach")
Link: http://lkml.kernel.org/r/1489758442-2877-1-git-send-email-vincent.guittot@linaro.org
[ Fixed typos, improved layout. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 36 insertions, 3 deletions

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 2805bd7c8994..03adf9fb48b1 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -3173,6 +3173,36 @@ static inline int propagate_entity_load_avg(struct sched_entity *se)
         return 1;
 }
 
+/*
+ * Check if we need to update the load and the utilization of a blocked
+ * group_entity:
+ */
+static inline bool skip_blocked_update(struct sched_entity *se)
+{
+        struct cfs_rq *gcfs_rq = group_cfs_rq(se);
+
+        /*
+         * If sched_entity still have not zero load or utilization, we have to
+         * decay it:
+         */
+        if (se->avg.load_avg || se->avg.util_avg)
+                return false;
+
+        /*
+         * If there is a pending propagation, we have to update the load and
+         * the utilization of the sched_entity:
+         */
+        if (gcfs_rq->propagate_avg)
+                return false;
+
+        /*
+         * Otherwise, the load and the utilization of the sched_entity is
+         * already zero and there is no pending propagation, so it will be a
+         * waste of time to try to decay it:
+         */
+        return true;
+}
+
 #else /* CONFIG_FAIR_GROUP_SCHED */
 
 static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force) {}
@@ -6961,6 +6991,8 @@ static void update_blocked_averages(int cpu)
          * list_add_leaf_cfs_rq() for details.
          */
         for_each_leaf_cfs_rq(rq, cfs_rq) {
+                struct sched_entity *se;
+
                 /* throttled entities do not contribute to load */
                 if (throttled_hierarchy(cfs_rq))
                         continue;
@@ -6968,9 +7000,10 @@ static void update_blocked_averages(int cpu)
                 if (update_cfs_rq_load_avg(cfs_rq_clock_task(cfs_rq), cfs_rq, true))
                         update_tg_load_avg(cfs_rq, 0);
 
-                /* Propagate pending load changes to the parent */
-                if (cfs_rq->tg->se[cpu])
-                        update_load_avg(cfs_rq->tg->se[cpu], 0);
+                /* Propagate pending load changes to the parent, if any: */
+                se = cfs_rq->tg->se[cpu];
+                if (se && !skip_blocked_update(se))
+                        update_load_avg(se, 0);
         }
         rq_unlock_irqrestore(rq, &rf);
 }