sched: fix ideal_runtime calculations for reniced tasks

fix ideal_runtime:

  - do not scale it using niced_granularity()
    it is against sum_exec_delta, so its wall-time, not fair-time.

  - move the whole check into __check_preempt_curr_fair()
    so that wakeup preemption can also benefit from the new logic.

this also results in code size reduction:

   text    data     bss     dec     hex filename
  13391     228    1204   14823    39e7 sched.o.before
  13369     228    1204   14801    39d1 sched.o.after

Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index 2d01bbc2d04a2a70d429cce65cdce2f5940ae1ca..892616bf2c77ab212d28823c6fe1bc76b1cb7825 100644 (file)
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -678,11 +678,31 @@ __check_preempt_curr_fair(struct cfs_rq *cfs_rq, struct sched_entity *se,
                          struct sched_entity *curr, unsigned long granularity)
 {
        s64 __delta = curr->fair_key - se->fair_key;
+       unsigned long ideal_runtime, delta_exec;
+
+       /*
+        * ideal_runtime is compared against sum_exec_runtime, which is
+        * walltime, hence do not scale.
+        */
+       ideal_runtime = max(sysctl_sched_latency / cfs_rq->nr_running,
+                       (unsigned long)sysctl_sched_min_granularity);
+
+       /*
+        * If we executed more than what the latency constraint suggests,
+        * reduce the rescheduling granularity. This way the total latency
+        * of how much a task is not scheduled converges to
+        * sysctl_sched_latency:
+        */
+       delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
+       if (delta_exec > ideal_runtime)
+               granularity = 0;
 
        /*
         * Take scheduling granularity into account - do not
         * preempt the current task unless the best task has
         * a larger than sched_granularity fairness advantage:
+        *
+        * scale granularity as key space is in fair_clock.
         */
        if (__delta > niced_granularity(curr, granularity))
                resched_task(rq_of(cfs_rq)->curr);
@@ -731,7 +751,6 @@ static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
 
 static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 {
-       unsigned long gran, ideal_runtime, delta_exec;
        struct sched_entity *next;
 
        /*
@@ -748,21 +767,8 @@ static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
        if (next == curr)
                return;
 
-       gran = sched_granularity(cfs_rq);
-       ideal_runtime = niced_granularity(curr,
-               max(sysctl_sched_latency / cfs_rq->nr_running,
-                   (unsigned long)sysctl_sched_min_granularity));
-       /*
-        * If we executed more than what the latency constraint suggests,
-        * reduce the rescheduling granularity. This way the total latency
-        * of how much a task is not scheduled converges to
-        * sysctl_sched_latency:
-        */
-       delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;
-       if (delta_exec > ideal_runtime)
-               gran = 0;
-
-       __check_preempt_curr_fair(cfs_rq, next, curr, gran);
+       __check_preempt_curr_fair(cfs_rq, next, curr,
+                       sched_granularity(cfs_rq));
 }
 
 /**************************************************