Skip to contentSkip to conversation

sched/fair: Remove the duplicate check from group_has_capacity()

PATCH In review Qi Zheng 2 participants 9 messages Aug 10, 2020 – Aug 12, 2020 Scheduler

lore
Share & tools
lore

Qi Zheng

author
#0 lore raw

PATCH 1/1 sched/fair: Remove the duplicate check from group_has_capacity()

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in group_is_overloaded() which was also called in group_classify().

	(sgs->group_capacity * imbalance_pct) <
                        (sgs->group_runnable * 100)

So just remove the duplicate check from group_has_capacity().

---
 kernel/sched/fair.c | 4 ----
 1 file changed, 4 deletions(-)
kernel/sched/fair.c +0 -4
index 2ba8f230feb9..a41903fb327a 100644
@@ -8234,10 +8234,6 @@ group_has_capacity(unsigned int imbalance_pct, struct sg_lb_stats *sgs)
 	if (sgs->sum_nr_running < sgs->group_weight)
 		return true;
 
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
-		return false;
-
 	if ((sgs->group_capacity * 100) >
 			(sgs->group_util * imbalance_pct))
 		return true;
Signature · 1 line
2.25.1
#1 lore raw
Quoted 9 lines · Qi Zheng

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in group_is_overloaded() which was also called in group_classify().

      (sgs->group_capacity * imbalance_pct) <
                        (sgs->group_runnable * 100)

Consider group_is_overloaded() returns false because of the first condition:

        if (sgs->sum_nr_running <= sgs->group_weight)
                return false;

then group_has_capacity() would be the first place where the group_runnable vs group_capacity comparison would be done.

Now in that specific case we'll actually only check it if

sgs->sum_nr_running == sgs->group_weight

and the only case where the runnable vs capacity check can fail here is if there's significant capacity pressure going on. TBH this capacity pressure could be happening even when there are fewer tasks than CPUs, so I'm not sure how intentional that corner case is.

For the

    sgs->sum_nr_running > sgs->group_weight

case I agree with your patch, there just is that oddity at the == case.

Quoted 22 lines

So just remove the duplicate check from group_has_capacity().

---
 kernel/sched/fair.c | 4 ----
 1 file changed, 4 deletions(-)
kernel/sched/fair.c +0 -4
index 2ba8f230feb9..a41903fb327a 100644
@@ -8234,10 +8234,6 @@ group_has_capacity(unsigned int imbalance_pct, struct sg_lb_stats *sgs)
      if (sgs->sum_nr_running < sgs->group_weight)
              return true;
 
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
-		return false;
-
      if ((sgs->group_capacity * 100) >
                      (sgs->group_util * imbalance_pct))
              return true;
author
#2 lore raw
Quoted 21 lines · Valentin Schneider
Quoted 9 lines · Qi Zheng

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in

    group_is_overloaded() which was also called in
    group_classify().

       (sgs->group_capacity * imbalance_pct) <
                         (sgs->group_runnable * 100)

Consider group_is_overloaded() returns false because of the first condition:

         if (sgs->sum_nr_running <= sgs->group_weight)
                 return false;

then group_has_capacity() would be the first place where the group_runnable vs group_capacity comparison would be done.

Quoted 8 lines

Now in that specific case we'll actually only check it if

   sgs->sum_nr_running == sgs->group_weight

and the only case where the runnable vs capacity check can fail here is if there's significant capacity pressure going on. TBH this capacity pressure could be happening even when there are fewer tasks than CPUs, so I'm not sure how intentional that corner case is.

Maybe some cpus in sg->cpumask are no longer active at the == case, which causes the significant capacity pressure?

Quoted 30 lines

For the

     sgs->sum_nr_running > sgs->group_weight

case I agree with your patch, there just is that oddity at the == case.

Quoted 22 lines

So just remove the duplicate check from group_has_capacity().

---
  kernel/sched/fair.c | 4 ----
  1 file changed, 4 deletions(-)
kernel/sched/fair.c +0 -4
index 2ba8f230feb9..a41903fb327a 100644
@@ -8234,10 +8234,6 @@ group_has_capacity(unsigned int imbalance_pct, struct sg_lb_stats *sgs)
       if (sgs->sum_nr_running < sgs->group_weight)
               return true;
 
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
-		return false;
-
       if ((sgs->group_capacity * 100) >
                       (sgs->group_util * imbalance_pct))
               return true;
#3 lore raw
Quoted 26 lines · Qi Zheng
Quoted 25 lines · Valentin Schneider
Quoted 9 lines · Qi Zheng

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in

    group_is_overloaded() which was also called in
    group_classify().

       (sgs->group_capacity * imbalance_pct) <
                         (sgs->group_runnable * 100)

Consider group_is_overloaded() returns false because of the first condition:

         if (sgs->sum_nr_running <= sgs->group_weight)
                 return false;

then group_has_capacity() would be the first place where the group_runnable vs group_capacity comparison would be done.

Now in that specific case we'll actually only check it if

   sgs->sum_nr_running == sgs->group_weight
Quoted 8 lines
Quoted 4 lines

and the only case where the runnable vs capacity check can fail here is if there's significant capacity pressure going on. TBH this capacity pressure could be happening even when there are fewer tasks than CPUs, so I'm not sure how intentional that corner case is.

Maybe some cpus in sg->cpumask are no longer active at the == case, which causes the significant capacity pressure?

That can only happen in that short window between deactivating a CPU and not having rebuilt the sched_domains yet, which sounds quite elusive.

author
#4 lore raw
Quoted 33 lines · Valentin Schneider
Quoted 31 lines · Qi Zheng
Quoted 29 lines · Valentin Schneider
Quoted 9 lines · Qi Zheng

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in

     group_is_overloaded() which was also called in
     group_classify().

        (sgs->group_capacity * imbalance_pct) <
                          (sgs->group_runnable * 100)

Consider group_is_overloaded() returns false because of the first condition:

          if (sgs->sum_nr_running <= sgs->group_weight)
                  return false;

then group_has_capacity() would be the first place where the group_runnable vs group_capacity comparison would be done.

Now in that specific case we'll actually only check it if

    sgs->sum_nr_running == sgs->group_weight

and the only case where the runnable vs capacity check can fail here is if there's significant capacity pressure going on. TBH this capacity pressure could be happening even when there are fewer tasks than CPUs, so I'm not sure how intentional that corner case is.

Quoted 7 lines
Quoted 3 lines

Maybe some cpus in sg->cpumask are no longer active at the == case, which causes the significant capacity pressure?

That can only happen in that short window between deactivating a CPU and not having rebuilt the sched_domains yet, which sounds quite elusive.

In fact, at the beginning, I added unlikely() here to hint the compiler:

- if ((sgs->group_capacity * imbalance_pct) <
- (sgs->group_runnable * 100))
+ if (unlikely((sgs->group_capacity * imbalance_pct) <
+ (sgs->group_runnable * 100)))

The corresponding patch is as follows:

[PATCH]sched/core: add unlikely in group_has_capacity()

Do you think it is necessary?

#5 lore raw
Quoted 49 lines · Qi Zheng
Quoted 33 lines · Valentin Schneider
Quoted 31 lines · Qi Zheng
Quoted 29 lines · Valentin Schneider
Quoted 9 lines · Qi Zheng

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in

     group_is_overloaded() which was also called in
     group_classify().

        (sgs->group_capacity * imbalance_pct) <
                          (sgs->group_runnable * 100)

Consider group_is_overloaded() returns false because of the first condition:

          if (sgs->sum_nr_running <= sgs->group_weight)
                  return false;

then group_has_capacity() would be the first place where the group_runnable vs group_capacity comparison would be done.

Now in that specific case we'll actually only check it if

    sgs->sum_nr_running == sgs->group_weight

and the only case where the runnable vs capacity check can fail here is if there's significant capacity pressure going on. TBH this capacity pressure could be happening even when there are fewer tasks than CPUs, so I'm not sure how intentional that corner case is.

Quoted 7 lines
Quoted 3 lines

Maybe some cpus in sg->cpumask are no longer active at the == case, which causes the significant capacity pressure?

That can only happen in that short window between deactivating a CPU and not having rebuilt the sched_domains yet, which sounds quite elusive.

In fact, at the beginning, I added unlikely() here to hint the compiler:

kernel/sched/fair.c +2 -2
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
+	if (unlikely((sgs->group_capacity * imbalance_pct) <
+			(sgs->group_runnable * 100)))
Quoted 5 lines

The corresponding patch is as follows:

[PATCH]sched/core: add unlikely in group_has_capacity()

Do you think it is necessary?

The "unlikely" approach has the benefit of keeping all corner cases in place. I was tempted to say it could still make sense to get rid of the extra check entirely, given that it has an impact only when:

- sum_nr_running == group_weight
- group capacity has been noticeably reduced

If sum_nr_running < group_weight, we won't evaluate it. If sum_nr_running > group_weight, we either won't call into
group_has_capacity() or we'll have checked it already in group_overloaded().

That said, it does make very much sense to check it in that == case. Vincent might have a different take on this, but right now I'd say the unlikely approach is the safest one of the two.

author
#6 lore raw
Quoted 64 lines · Valentin Schneider
Quoted 49 lines · Qi Zheng
Quoted 33 lines · Valentin Schneider
Quoted 31 lines · Qi Zheng
Quoted 29 lines · Valentin Schneider
Quoted 9 lines · Qi Zheng

1. The group_has_capacity() function is only called in group_classify().
2. The following inequality has already been checked in

      group_is_overloaded() which was also called in
      group_classify().

         (sgs->group_capacity * imbalance_pct) <
                           (sgs->group_runnable * 100)

Consider group_is_overloaded() returns false because of the first condition:

           if (sgs->sum_nr_running <= sgs->group_weight)
                   return false;

then group_has_capacity() would be the first place where the group_runnable vs group_capacity comparison would be done.

Now in that specific case we'll actually only check it if

     sgs->sum_nr_running == sgs->group_weight

and the only case where the runnable vs capacity check can fail here is if there's significant capacity pressure going on. TBH this capacity pressure could be happening even when there are fewer tasks than CPUs, so I'm not sure how intentional that corner case is.

Quoted 7 lines
Quoted 3 lines

Maybe some cpus in sg->cpumask are no longer active at the == case, which causes the significant capacity pressure?

That can only happen in that short window between deactivating a CPU and not having rebuilt the sched_domains yet, which sounds quite elusive.

In fact, at the beginning, I added unlikely() here to hint the compiler:

kernel/sched/fair.c +2 -2
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
+	if (unlikely((sgs->group_capacity * imbalance_pct) <
+			(sgs->group_runnable * 100)))
Quoted 5 lines

The corresponding patch is as follows:

[PATCH]sched/core: add unlikely in group_has_capacity()

Do you think it is necessary?

The "unlikely" approach has the benefit of keeping all corner cases in place. I was tempted to say it could still make sense to get rid of the extra check entirely, given that it has an impact only when:

- sum_nr_running == group_weight
- group capacity has been noticeably reduced

Quoted 9 lines

If sum_nr_running < group_weight, we won't evaluate it. If sum_nr_running > group_weight, we either won't call into
group_has_capacity() or we'll have checked it already in group_overloaded().

That said, it does make very much sense to check it in that == case. Vincent might have a different take on this, but right now I'd say the unlikely approach is the safest one of the two.

So what should I do next? Do I resubmit a patch with unlikely() or add your email to the old patch([PATCH]sched/core: add unlikely in group_has_capacity())? Or continue to wait for suggestions from other maintainers?

#7 lore raw
Quoted 32 lines · Qi Zheng
Quoted 21 lines · Valentin Schneider
Quoted 7 lines · Qi Zheng

In fact, at the beginning, I added unlikely() here to hint the compiler:

(quoted diff) +2 -2
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
+	if (unlikely((sgs->group_capacity * imbalance_pct) <
+			(sgs->group_runnable * 100)))
Quoted 5 lines

The corresponding patch is as follows:

[PATCH]sched/core: add unlikely in group_has_capacity()

Do you think it is necessary?

The "unlikely" approach has the benefit of keeping all corner cases in place. I was tempted to say it could still make sense to get rid of the extra check entirely, given that it has an impact only when:

- sum_nr_running == group_weight
- group capacity has been noticeably reduced

Quoted 9 lines

If sum_nr_running < group_weight, we won't evaluate it. If sum_nr_running > group_weight, we either won't call into
group_has_capacity() or we'll have checked it already in group_overloaded().

That said, it does make very much sense to check it in that == case. Vincent might have a different take on this, but right now I'd say the unlikely approach is the safest one of the two.

Quoted 4 lines

So what should I do next? Do I resubmit a patch with unlikely() or add your email to the old patch([PATCH]sched/core: add unlikely in group_has_capacity())? Or continue to wait for suggestions from other maintainers?

I guess you can add a reply to the original thread where you had the unlikely() to point out *removing* the check isn't 100% harmless.

Vincent might want to have a look at it, but AFAIA he's on holidays ATM.

author
#8 lore raw
Quoted 39 lines · Valentin Schneider
Quoted 32 lines · Qi Zheng
Quoted 21 lines · Valentin Schneider
Quoted 7 lines · Qi Zheng

In fact, at the beginning, I added unlikely() here to hint the compiler:

(quoted diff) +2 -2
-	if ((sgs->group_capacity * imbalance_pct) <
-			(sgs->group_runnable * 100))
+	if (unlikely((sgs->group_capacity * imbalance_pct) <
+			(sgs->group_runnable * 100)))
Quoted 5 lines

The corresponding patch is as follows:

[PATCH]sched/core: add unlikely in group_has_capacity()

Do you think it is necessary?

The "unlikely" approach has the benefit of keeping all corner cases in place. I was tempted to say it could still make sense to get rid of the extra check entirely, given that it has an impact only when:

- sum_nr_running == group_weight
- group capacity has been noticeably reduced

Quoted 9 lines

If sum_nr_running < group_weight, we won't evaluate it. If sum_nr_running > group_weight, we either won't call into
group_has_capacity() or we'll have checked it already in group_overloaded().

That said, it does make very much sense to check it in that == case. Vincent might have a different take on this, but right now I'd say the unlikely approach is the safest one of the two.

Quoted 4 lines

So what should I do next? Do I resubmit a patch with unlikely() or add your email to the old patch([PATCH]sched/core: add unlikely in group_has_capacity())? Or continue to wait for suggestions from other maintainers?

Quoted 5 lines

I guess you can add a reply to the original thread where you had the unlikely() to point out *removing* the check isn't 100% harmless.

Vincent might want to have a look at it, but AFAIA he's on holidays ATM.

Okay, I will reply to the old patch and add your email to it. Thanks for your comments.

Yours,
Qi Zheng