3 files changed, 28 insertions, 26 deletions

diff --git a/kernel/sched.c b/kernel/sched.c
index 96e9b82246d2..6798328a2e0e 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -2180,12 +2180,6 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
         if (task_running(rq, p))
                 return 0;
 
-        /*
-         * Aggressive migration if too many balance attempts have failed:
-         */
-        if (sd->nr_balance_failed > sd->cache_nice_tries)
-                return 1;
-
         return 1;
 }
 
@@ -4923,7 +4917,7 @@ static inline void sched_init_granularity(void)
         if (sysctl_sched_granularity > gran_limit)
                 sysctl_sched_granularity = gran_limit;
 
-        sysctl_sched_runtime_limit = sysctl_sched_granularity * 8;
+        sysctl_sched_runtime_limit = sysctl_sched_granularity * 5;
         sysctl_sched_wakeup_granularity = sysctl_sched_granularity / 2;
 }
 
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index fedbb51bba96..4d6b7e2df2aa 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -19,7 +19,7 @@
 
 /*
  * Preemption granularity:
- * (default: 2 msec, units: nanoseconds)
+ * (default: 10 msec, units: nanoseconds)
  *
  * NOTE: this granularity value is not the same as the concept of
  * 'timeslice length' - timeslices in CFS will typically be somewhat
@@ -31,18 +31,17 @@
  * number of CPUs. (i.e. factor 2x on 2-way systems, 3x on 4-way
  * systems, 4x on 8-way systems, 5x on 16-way systems, etc.)
  */
-unsigned int sysctl_sched_granularity __read_mostly = 2000000000ULL/HZ;
+unsigned int sysctl_sched_granularity __read_mostly = 10000000UL;
 
 /*
  * SCHED_BATCH wake-up granularity.
- * (default: 10 msec, units: nanoseconds)
+ * (default: 25 msec, units: nanoseconds)
  *
  * This option delays the preemption effects of decoupled workloads
  * and reduces their over-scheduling. Synchronous workloads will still
  * have immediate wakeup/sleep latencies.
  */
-unsigned int sysctl_sched_batch_wakeup_granularity __read_mostly =
-                                                        10000000000ULL/HZ;
+unsigned int sysctl_sched_batch_wakeup_granularity __read_mostly = 25000000UL;
 
 /*
  * SCHED_OTHER wake-up granularity.
@@ -52,12 +51,12 @@ unsigned int sysctl_sched_batch_wakeup_granularity __read_mostly =
  * and reduces their over-scheduling. Synchronous workloads will still
  * have immediate wakeup/sleep latencies.
  */
-unsigned int sysctl_sched_wakeup_granularity __read_mostly = 1000000000ULL/HZ;
+unsigned int sysctl_sched_wakeup_granularity __read_mostly = 1000000UL;
 
 unsigned int sysctl_sched_stat_granularity __read_mostly;
 
 /*
- * Initialized in sched_init_granularity():
+ * Initialized in sched_init_granularity() [to 5 times the base granularity]:
  */
 unsigned int sysctl_sched_runtime_limit __read_mostly;
 
@@ -304,9 +303,9 @@ __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr)
         delta_mine = calc_delta_mine(delta_exec, curr->load.weight, lw);
 
         if (cfs_rq->sleeper_bonus > sysctl_sched_granularity) {
-                delta = min(cfs_rq->sleeper_bonus, (u64)delta_exec);
-                delta = calc_delta_mine(delta, curr->load.weight, lw);
-                delta = min((u64)delta, cfs_rq->sleeper_bonus);
+                delta = min((u64)delta_mine, cfs_rq->sleeper_bonus);
+                delta = min(delta, (unsigned long)(
+                        (long)sysctl_sched_runtime_limit - curr->wait_runtime));
                 cfs_rq->sleeper_bonus -= delta;
                 delta_mine -= delta;
         }
@@ -494,6 +493,13 @@ static void __enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
         unsigned long load = cfs_rq->load.weight, delta_fair;
         long prev_runtime;
 
+        /*
+         * Do not boost sleepers if there's too much bonus 'in flight'
+         * already:
+         */
+        if (unlikely(cfs_rq->sleeper_bonus > sysctl_sched_runtime_limit))
+                return;
+
         if (sysctl_sched_features & SCHED_FEAT_SLEEPER_LOAD_AVG)
                 load = rq_of(cfs_rq)->cpu_load[2];
 
@@ -513,16 +519,13 @@ static void __enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
 
         prev_runtime = se->wait_runtime;
         __add_wait_runtime(cfs_rq, se, delta_fair);
+        schedstat_add(cfs_rq, wait_runtime, se->wait_runtime);
         delta_fair = se->wait_runtime - prev_runtime;
 
         /*
          * Track the amount of bonus we've given to sleepers:
          */
         cfs_rq->sleeper_bonus += delta_fair;
-        if (unlikely(cfs_rq->sleeper_bonus > sysctl_sched_runtime_limit))
-                cfs_rq->sleeper_bonus = sysctl_sched_runtime_limit;
-
-        schedstat_add(cfs_rq, wait_runtime, se->wait_runtime);
 }
 
 static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
@@ -1044,7 +1047,7 @@ static void task_new_fair(struct rq *rq, struct task_struct *p)
          * -granularity/2, so initialize the task with that:
          */
         if (sysctl_sched_features & SCHED_FEAT_START_DEBIT)
-                p->se.wait_runtime = -(sysctl_sched_granularity / 2);
+                p->se.wait_runtime = -((long)sysctl_sched_granularity / 2);
 
         __enqueue_entity(cfs_rq, se);
 }
@@ -1057,7 +1060,7 @@ static void task_new_fair(struct rq *rq, struct task_struct *p)
  */
 static void set_curr_task_fair(struct rq *rq)
 {
-        struct sched_entity *se = &rq->curr.se;
+        struct sched_entity *se = &rq->curr->se;
 
         for_each_sched_entity(se)
                 set_next_entity(cfs_rq_of(se), se);
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index dcdcad632fd9..4b87476a02d0 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -207,10 +207,15 @@ static void task_tick_rt(struct rq *rq, struct task_struct *p)
                 return;
 
         p->time_slice = static_prio_timeslice(p->static_prio);
-        set_tsk_need_resched(p);
 
-        /* put it at the end of the queue: */
-        requeue_task_rt(rq, p);
+        /*
+         * Requeue to the end of queue if we are not the only element
+         * on the queue:
+         */
+        if (p->run_list.prev != p->run_list.next) {
+                requeue_task_rt(rq, p);
+                set_tsk_need_resched(p);
+        }
 }
 
 static struct sched_class rt_sched_class __read_mostly = {