[PATCH] sched: Reduce the rate of needless idle load balancing

[PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

The current no_hz idle load balancer do load balancing on *all* idle cpus,
even though the time due to load balance for a particular
idle cpu could be still a while in future.  This introduces a much
higher load balancing rate than what is necessary.  The patch
changes the behavior by only doing idle load balancing on
behalf of an idle cpu only when time is due for load balancing.

On SGI's systems with over 3000 cores, the cpu responsible for idle balancing
got overwhelmed with idle balancing, and introduces a lot of OS noise
to workloads.  This patch fixes the issue.

Thanks.

Tim

Acked-by: Russ Anderson <rja@sgi.com>
Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
---
 kernel/sched/fair.c | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 9b4c4f3..97132db 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
 
 		rq = cpu_rq(balance_cpu);
 
-		raw_spin_lock_irq(&rq->lock);
-		update_rq_clock(rq);
-		update_idle_cpu_load(rq);
-		raw_spin_unlock_irq(&rq->lock);
-
-		rebalance_domains(rq, CPU_IDLE);
+		/*
+		 * If time for next balance is due,
+		 * do the balance.
+		 */
+		if (time_after(jiffies + 1, rq->next_balance)) {
+			raw_spin_lock_irq(&rq->lock);
+			update_rq_clock(rq);
+			update_idle_cpu_load(rq);
+			raw_spin_unlock_irq(&rq->lock);
+			rebalance_domains(rq, CPU_IDLE);
+		}
 
 		if (time_after(this_rq->next_balance, rq->next_balance))
 			this_rq->next_balance = rq->next_balance;
-- 
1.7.11.7

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Jason Low]

On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:

> diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> index 9b4c4f3..97132db 100644
> --- a/kernel/sched/fair.c
> +++ b/kernel/sched/fair.c
> @@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
>
>                 rq = cpu_rq(balance_cpu);
>
> -               raw_spin_lock_irq(&rq->lock);
> -               update_rq_clock(rq);
> -               update_idle_cpu_load(rq);
> -               raw_spin_unlock_irq(&rq->lock);
> -
> -               rebalance_domains(rq, CPU_IDLE);
> +               /*
> +                * If time for next balance is due,
> +                * do the balance.
> +                */
> +               if (time_after(jiffies + 1, rq->next_balance)) {

Hi Tim,

If we want to do idle load balancing only when it is due for a
balance, shouldn't the above just be "if (time_after(jiffies,
rq->next_balance))"?

> +                       raw_spin_lock_irq(&rq->lock);
> +                       update_rq_clock(rq);
> +                       update_idle_cpu_load(rq);
> +                       raw_spin_unlock_irq(&rq->lock);
> +                       rebalance_domains(rq, CPU_IDLE);
> +               }
>
>                 if (time_after(this_rq->next_balance, rq->next_balance))
>                         this_rq->next_balance = rq->next_balance;

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Rik van Riel]

On 05/20/2014 04:51 PM, Jason Low wrote:
> On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> 
>> diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
>> index 9b4c4f3..97132db 100644
>> --- a/kernel/sched/fair.c
>> +++ b/kernel/sched/fair.c
>> @@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
>>
>>                 rq = cpu_rq(balance_cpu);
>>
>> -               raw_spin_lock_irq(&rq->lock);
>> -               update_rq_clock(rq);
>> -               update_idle_cpu_load(rq);
>> -               raw_spin_unlock_irq(&rq->lock);
>> -
>> -               rebalance_domains(rq, CPU_IDLE);
>> +               /*
>> +                * If time for next balance is due,
>> +                * do the balance.
>> +                */
>> +               if (time_after(jiffies + 1, rq->next_balance)) {
> 
> Hi Tim,
> 
> If we want to do idle load balancing only when it is due for a
> balance, shouldn't the above just be "if (time_after(jiffies,
> rq->next_balance))"?

I was wondering the same.

Everything else gets my

Reviewed-by: Rik van Riel <riel@redhat.com>

-- 
All rights reversed

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> 
> > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> > index 9b4c4f3..97132db 100644
> > --- a/kernel/sched/fair.c
> > +++ b/kernel/sched/fair.c
> > @@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
> >
> >                 rq = cpu_rq(balance_cpu);
> >
> > -               raw_spin_lock_irq(&rq->lock);
> > -               update_rq_clock(rq);
> > -               update_idle_cpu_load(rq);
> > -               raw_spin_unlock_irq(&rq->lock);
> > -
> > -               rebalance_domains(rq, CPU_IDLE);
> > +               /*
> > +                * If time for next balance is due,
> > +                * do the balance.
> > +                */
> > +               if (time_after(jiffies + 1, rq->next_balance)) {
> 
> Hi Tim,
> 
> If we want to do idle load balancing only when it is due for a
> balance, shouldn't the above just be "if (time_after(jiffies,
> rq->next_balance))"?

If rq->next_balance and jiffies are equal, then
time_after(jiffies, rq->next_balance) check will be false and
you will not do balance.  But actually you want to balance
for this case so the jiffies+1 was used.

Tim

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

On Tue, 2014-05-20 at 13:59 -0700, Tim Chen wrote:
> On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> > On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> > 
> > > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> > > index 9b4c4f3..97132db 100644
> > > --- a/kernel/sched/fair.c
> > > +++ b/kernel/sched/fair.c
> > > @@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
> > >
> > >                 rq = cpu_rq(balance_cpu);
> > >
> > > -               raw_spin_lock_irq(&rq->lock);
> > > -               update_rq_clock(rq);
> > > -               update_idle_cpu_load(rq);
> > > -               raw_spin_unlock_irq(&rq->lock);
> > > -
> > > -               rebalance_domains(rq, CPU_IDLE);
> > > +               /*
> > > +                * If time for next balance is due,
> > > +                * do the balance.
> > > +                */
> > > +               if (time_after(jiffies + 1, rq->next_balance)) {
> > 
> > Hi Tim,
> > 
> > If we want to do idle load balancing only when it is due for a
> > balance, shouldn't the above just be "if (time_after(jiffies,
> > rq->next_balance))"?
> 
> If rq->next_balance and jiffies are equal, then
> time_after(jiffies, rq->next_balance) check will be false and
> you will not do balance.  But actually you want to balance
> for this case so the jiffies+1 was used.

So maybe I should switch the check to 
if (time_before(rq->next_balance, jiffies))

Tim

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Joe Perches]

On Tue, 2014-05-20 at 14:04 -0700, Tim Chen wrote:
> On Tue, 2014-05-20 at 13:59 -0700, Tim Chen wrote:
> > On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> > > On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> > > > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
[]
> > > If we want to do idle load balancing only when it is due for a
> > > balance, shouldn't the above just be "if (time_after(jiffies,
> > > rq->next_balance))"?
> > 
> > If rq->next_balance and jiffies are equal, then
> > time_after(jiffies, rq->next_balance) check will be false and
> > you will not do balance.  But actually you want to balance
> > for this case so the jiffies+1 was used.
> 
> So maybe I should switch the check to 
> if (time_before(rq->next_balance, jiffies))

time_after_eq() or time_is_after_eq_jiffies()

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

On Tue, 2014-05-20 at 18:15 -0700, Joe Perches wrote:
> On Tue, 2014-05-20 at 14:04 -0700, Tim Chen wrote:
> > On Tue, 2014-05-20 at 13:59 -0700, Tim Chen wrote:
> > > On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> > > > On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> > > > > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> []
> > > > If we want to do idle load balancing only when it is due for a
> > > > balance, shouldn't the above just be "if (time_after(jiffies,
> > > > rq->next_balance))"?
> > > 
> > > If rq->next_balance and jiffies are equal, then
> > > time_after(jiffies, rq->next_balance) check will be false and
> > > you will not do balance.  But actually you want to balance
> > > for this case so the jiffies+1 was used.
> > 
> > So maybe I should switch the check to 
> > if (time_before(rq->next_balance, jiffies))
> 
> time_after_eq() or time_is_after_eq_jiffies()
> 
> 

I prefer time_after_eq to keep the code style consistent with the
rest of the code in fair.c.

Tim

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Davidlohr Bueso]

On Wed, 2014-05-21 at 09:37 -0700, Tim Chen wrote:
> On Tue, 2014-05-20 at 18:15 -0700, Joe Perches wrote:
> > On Tue, 2014-05-20 at 14:04 -0700, Tim Chen wrote:
> > > On Tue, 2014-05-20 at 13:59 -0700, Tim Chen wrote:
> > > > On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> > > > > On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> > > > > > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> > []
> > > > > If we want to do idle load balancing only when it is due for a
> > > > > balance, shouldn't the above just be "if (time_after(jiffies,
> > > > > rq->next_balance))"?
> > > > 
> > > > If rq->next_balance and jiffies are equal, then
> > > > time_after(jiffies, rq->next_balance) check will be false and
> > > > you will not do balance.  But actually you want to balance
> > > > for this case so the jiffies+1 was used.
> > > 
> > > So maybe I should switch the check to 
> > > if (time_before(rq->next_balance, jiffies))
> > 
> > time_after_eq() or time_is_after_eq_jiffies()
> > 
> > 
> 
> I prefer time_after_eq to keep the code style consistent with the
> rest of the code in fair.c.

Should all the code be updated then? We should use the existing
interfaces if available.

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

On Wed, 2014-05-21 at 11:26 -0700, Davidlohr Bueso wrote:
> On Wed, 2014-05-21 at 09:37 -0700, Tim Chen wrote:
> > On Tue, 2014-05-20 at 18:15 -0700, Joe Perches wrote:
> > > On Tue, 2014-05-20 at 14:04 -0700, Tim Chen wrote:
> > > > On Tue, 2014-05-20 at 13:59 -0700, Tim Chen wrote:
> > > > > On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> > > > > > On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> > > > > > > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> > > []
> > > > > > If we want to do idle load balancing only when it is due for a
> > > > > > balance, shouldn't the above just be "if (time_after(jiffies,
> > > > > > rq->next_balance))"?
> > > > > 
> > > > > If rq->next_balance and jiffies are equal, then
> > > > > time_after(jiffies, rq->next_balance) check will be false and
> > > > > you will not do balance.  But actually you want to balance
> > > > > for this case so the jiffies+1 was used.
> > > > 
> > > > So maybe I should switch the check to 
> > > > if (time_before(rq->next_balance, jiffies))
> > > 
> > > time_after_eq() or time_is_after_eq_jiffies()
> > > 
> > > 
> > 
> > I prefer time_after_eq to keep the code style consistent with the
> > rest of the code in fair.c.
> 
> Should all the code be updated then? We should use the existing
> interfaces if available.
> 

BTW, if this code was to be updated, time_is_before_eq_jiffies(rq->next_balance) 
check will be the correct thing to do for the patch. This expands to
time_after_eq(jiffies, rq->next_balance), which is what we want.

So something like:

                if (time_is_before_eq_jiffies(rq->next_balance)) {
                        raw_spin_lock_irq(&rq->lock);
                        update_rq_clock(rq);
                        update_idle_cpu_load(rq);
                        raw_spin_unlock_irq(&rq->lock);
                        rebalance_domains(rq, CPU_IDLE);
                }


But I don't think this change is making the code logic any clearer.  
I prefer time_after_eq(jiffies, rq->next_balance), which is more
readable.

Tim

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Jason Low]

On Tue, May 20, 2014 at 1:59 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
>> On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
>>
>> > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
>> > index 9b4c4f3..97132db 100644
>> > --- a/kernel/sched/fair.c
>> > +++ b/kernel/sched/fair.c
>> > @@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
>> >
>> >                 rq = cpu_rq(balance_cpu);
>> >
>> > -               raw_spin_lock_irq(&rq->lock);
>> > -               update_rq_clock(rq);
>> > -               update_idle_cpu_load(rq);
>> > -               raw_spin_unlock_irq(&rq->lock);
>> > -
>> > -               rebalance_domains(rq, CPU_IDLE);
>> > +               /*
>> > +                * If time for next balance is due,
>> > +                * do the balance.
>> > +                */
>> > +               if (time_after(jiffies + 1, rq->next_balance)) {
>>
>> Hi Tim,
>>
>> If we want to do idle load balancing only when it is due for a
>> balance, shouldn't the above just be "if (time_after(jiffies,
>> rq->next_balance))"?
>
> If rq->next_balance and jiffies are equal, then
> time_after(jiffies, rq->next_balance) check will be false and
> you will not do balance.  But actually you want to balance
> for this case so the jiffies+1 was used.

Hi Tim, Rik

Yes, that makes sense that we want to balance if they are equal. We
may also consider using "if (time_after_eq(jiffies,
rq->next_balance)".

Reviewed-by: Jason Low <jason.low2@hp.com>

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

On Tue, 2014-05-20 at 14:09 -0700, Jason Low wrote:
> On Tue, May 20, 2014 at 1:59 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> > On Tue, 2014-05-20 at 13:51 -0700, Jason Low wrote:
> >> On Tue, May 20, 2014 at 1:17 PM, Tim Chen <tim.c.chen@linux.intel.com> wrote:
> >>
> >> > diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> >> > index 9b4c4f3..97132db 100644
> >> > --- a/kernel/sched/fair.c
> >> > +++ b/kernel/sched/fair.c
> >> > @@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
> >> >
> >> >                 rq = cpu_rq(balance_cpu);
> >> >
> >> > -               raw_spin_lock_irq(&rq->lock);
> >> > -               update_rq_clock(rq);
> >> > -               update_idle_cpu_load(rq);
> >> > -               raw_spin_unlock_irq(&rq->lock);
> >> > -
> >> > -               rebalance_domains(rq, CPU_IDLE);
> >> > +               /*
> >> > +                * If time for next balance is due,
> >> > +                * do the balance.
> >> > +                */
> >> > +               if (time_after(jiffies + 1, rq->next_balance)) {
> >>
> >> Hi Tim,
> >>
> >> If we want to do idle load balancing only when it is due for a
> >> balance, shouldn't the above just be "if (time_after(jiffies,
> >> rq->next_balance))"?
> >
> > If rq->next_balance and jiffies are equal, then
> > time_after(jiffies, rq->next_balance) check will be false and
> > you will not do balance.  But actually you want to balance
> > for this case so the jiffies+1 was used.
> 
> Hi Tim, Rik
> 
> Yes, that makes sense that we want to balance if they are equal. We
> may also consider using "if (time_after_eq(jiffies,
> rq->next_balance)".

That sounds good.  Thanks.
> 
> Reviewed-by: Jason Low <jason.low2@hp.com>


Tim

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Tim Chen]

On Tue, 2014-05-20 at 14:09 -0700, Jason Low wrote:

> Hi Tim, Rik
> 
> Yes, that makes sense that we want to balance if they are equal. We
> may also consider using "if (time_after_eq(jiffies,
> rq->next_balance)".
> 
> Reviewed-by: Jason Low <jason.low2@hp.com>

Jason & Rik,

Thanks for reviewing the patch.  I've updated the patch below as
suggested.

Tim

---

From: Tim Chen <tim.c.chen@linux.intel.com>
Subject: [PATCH v2] sched: Reduce the rate of needless idle load balancing


The current no_hz idle load balancer do load balancing for *all* idle cpus,
even though the time due to load balance for a particular
idle cpu could be still a while in the future.  This introduces a much
higher load balancing rate than what is necessary.  The patch
changes the behavior by only doing idle load balancing on
behalf of an idle cpu only when it is due for load balancing.

On SGI's systems with over 3000 cores, the cpu responsible for idle balancing
got overwhelmed with idle balancing, and introduces a lot of OS noise
to workloads.  This patch fixes the issue.

Acked-by: Russ Anderson <rja@sgi.com>
Reviewed-by: Rik van Riel <riel@redhat.com>
Reviewed-by: Jason Low <jason.low2@hp.com>
Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
---
 kernel/sched/fair.c | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 9b4c4f3..b826c3a 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -6764,12 +6764,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
 
 		rq = cpu_rq(balance_cpu);
 
-		raw_spin_lock_irq(&rq->lock);
-		update_rq_clock(rq);
-		update_idle_cpu_load(rq);
-		raw_spin_unlock_irq(&rq->lock);
-
-		rebalance_domains(rq, CPU_IDLE);
+		/*
+		 * If time for next balance is due,
+		 * do the balance.
+		 */
+		if (time_after_eq(jiffies, rq->next_balance)) {
+			raw_spin_lock_irq(&rq->lock);
+			update_rq_clock(rq);
+			update_idle_cpu_load(rq);
+			raw_spin_unlock_irq(&rq->lock);
+			rebalance_domains(rq, CPU_IDLE);
+		}
 
 		if (time_after(this_rq->next_balance, rq->next_balance))
 			this_rq->next_balance = rq->next_balance;
-- 
1.7.11.7

Re: [PATCH] sched: Reduce the rate of needless idle load balancing

[Peter Zijlstra]

[-- Attachment #1: Type: text/plain, Size: 1013 bytes --]

On Tue, May 20, 2014 at 02:39:27PM -0700, Tim Chen wrote:
> From: Tim Chen <tim.c.chen@linux.intel.com>
> Subject: [PATCH v2] sched: Reduce the rate of needless idle load balancing
> 
> 
> The current no_hz idle load balancer do load balancing for *all* idle cpus,
> even though the time due to load balance for a particular
> idle cpu could be still a while in the future.  This introduces a much
> higher load balancing rate than what is necessary.  The patch
> changes the behavior by only doing idle load balancing on
> behalf of an idle cpu only when it is due for load balancing.
> 
> On SGI's systems with over 3000 cores, the cpu responsible for idle balancing
> got overwhelmed with idle balancing, and introduces a lot of OS noise
> to workloads.  This patch fixes the issue.
> 
> Acked-by: Russ Anderson <rja@sgi.com>
> Reviewed-by: Rik van Riel <riel@redhat.com>
> Reviewed-by: Jason Low <jason.low2@hp.com>
> Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
> ---

Thanks!

[-- Attachment #2: Type: application/pgp-signature, Size: 836 bytes --]

[tip:sched/core] sched/balancing: Reduce the rate of needless idle load balancing

[tip-bot for Tim Chen]

Commit-ID:  ed61bbc69c773465782476c7e5869fa5607fa73a
Gitweb:     http://git.kernel.org/tip/ed61bbc69c773465782476c7e5869fa5607fa73a
Author:     Tim Chen <tim.c.chen@linux.intel.com>
AuthorDate: Tue, 20 May 2014 14:39:27 -0700
Committer:  Ingo Molnar <mingo@kernel.org>
CommitDate: Thu, 5 Jun 2014 11:52:01 +0200

sched/balancing: Reduce the rate of needless idle load balancing

The current no_hz idle load balancer do load balancing for *all* idle cpus,
even though the time due to load balance for a particular
idle cpu could be still a while in the future.  This introduces a much
higher load balancing rate than what is necessary.  The patch
changes the behavior by only doing idle load balancing on
behalf of an idle cpu only when it is due for load balancing.

On SGI's systems with over 3000 cores, the cpu responsible for idle balancing
got overwhelmed with idle balancing, and introduces a lot of OS noise
to workloads.  This patch fixes the issue.

Signed-off-by: Tim Chen <tim.c.chen@linux.intel.com>
Acked-by: Russ Anderson <rja@sgi.com>
Reviewed-by: Rik van Riel <riel@redhat.com>
Reviewed-by: Jason Low <jason.low2@hp.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Len Brown <len.brown@intel.com>
Cc: Dimitri Sivanich <sivanich@sgi.com>
Cc: Hedi Berriche <hedi@sgi.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: MichelLespinasse <walken@google.com>
Cc: Peter Hurley <peter@hurleysoftware.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: http://lkml.kernel.org/r/1400621967.2970.280.camel@schen9-DESK
Signed-off-by: Ingo Molnar <mingo@kernel.org>
---
 kernel/sched/fair.c | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index b71d8c3..7a0c000 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -7193,12 +7193,17 @@ static void nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle)
 
 		rq = cpu_rq(balance_cpu);
 
-		raw_spin_lock_irq(&rq->lock);
-		update_rq_clock(rq);
-		update_idle_cpu_load(rq);
-		raw_spin_unlock_irq(&rq->lock);
-
-		rebalance_domains(rq, CPU_IDLE);
+		/*
+		 * If time for next balance is due,
+		 * do the balance.
+		 */
+		if (time_after_eq(jiffies, rq->next_balance)) {
+			raw_spin_lock_irq(&rq->lock);
+			update_rq_clock(rq);
+			update_idle_cpu_load(rq);
+			raw_spin_unlock_irq(&rq->lock);
+			rebalance_domains(rq, CPU_IDLE);
+		}
 
 		if (time_after(this_rq->next_balance, rq->next_balance))
 			this_rq->next_balance = rq->next_balance;