[PATCH v13] sched/deadline: support dl task migration during cpu hotplug

[PATCH v13] sched/deadline: support dl task migration during cpu hotplug

[Wanpeng Li]

I observe that dl task can't be migrated to other cpus during cpu hotplug,
in addition, task may/may not be running again if cpu is added back. The
root cause which I found is that dl task will be throtted and removed from
dl rq after comsuming all budget, which leads to stop task can't pick it up
from dl rq and migrate to other cpus during hotplug.

The method to reproduce:
schedtool -E -t 50000:100000 -e ./test
Actually test is just a simple for loop. Then observe which cpu the test
task is on.
echo 0 > /sys/devices/system/cpu/cpuN/online

This patch adds the dl task migration during cpu hotplug by finding a most
suitable later deadline rq after dl timer fire if current rq is offline,
if fail to find a suitable later deadline rq then fallback to any eligible
online cpu in order that the deadline task will come back to us, and the
push/pull mechanism should then move it around properly.

Suggested-and-acked-by: Juri Lelli <juri.lelli@arm.com>
Signed-off-by: Wanpeng Li <wanpeng.li@linux.intel.com>
---
v12 -> 13:
 * move hotplug stuff to CONFIG_SMP in order to fix the error reported by kbuild test robot
v11 -> v12:
 * s/WARN_ON/BUG_ON
v10 -> v11:
 * fix codes comments
 * tsk_cpus_allowed(p) shouldn't be on separate lines
 * introduce a helper function to fold dl task migration during cpu hotplug support
v9 -> v10:
 * fix the "WARNING: line over 80 characters"
 * handle no admission control
v8 -> v9:
 * align tsk_cpus_allowed(p) to cpu_active_mask
 * add WARN_ON(1)
 * don't resched_curr if later_rq come from the cpumask_any_and()
v7 -> v8:
 * remove rd->span related modification since Pang's commit 16b269436b72
   (sched/deadline: Modify cpudl::free_cpus to reflect rd->online) merged
   upstream, which Juri pointed out can handle the exclusive cpusets.
 * rebase
v6 -> v7:
 * rebase
v5 -> v6:
 * add double_lock_balance in the fallback path
v4 -> v5:
 * remove raw_spin_unlock(&rq->lock)
 * cleanup codes, spotted by Peterz
 * cleanup patch description
v3 -> v4:
 * use tsk_cpus_allowed wrapper
 * fix compile error
v2 -> v3:
 * don't get_task_struct
 * if cannot preempt any rq, fallback to pick any online cpus
 * use cpu_active_mask as original later_mask if cpu is offline
v1 -> v2:
 * push the task to another cpu in dl_task_timer() if rq is offline.

 kernel/sched/deadline.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
index 24c18dc..60b7e90 100644
--- a/kernel/sched/deadline.c
+++ b/kernel/sched/deadline.c
@@ -218,6 +218,54 @@ static inline void set_post_schedule(struct rq *rq)
 	rq->post_schedule = has_pushable_dl_tasks(rq);
 }
 
+static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq);
+
+static void dl_task_migration(struct rq *rq, struct task_struct *p)
+{
+	struct rq *later_rq = NULL;
+	bool fallback = false;
+
+	later_rq = find_lock_later_rq(p, rq);
+
+	if (!later_rq) {
+		int cpu;
+
+		/*
+		 * If we cannot preempt any rq, fall back to pick any
+		 * online cpu.
+		 */
+		fallback = true;
+		cpu = cpumask_any_and(cpu_active_mask, tsk_cpus_allowed(p));
+		if (cpu >= nr_cpu_ids) {
+			if (dl_bandwidth_enabled()) {
+				/*
+				 * Fail to find any suitable cpu.
+				 * The task will never come back!
+				 */
+				BUG_ON(1);
+				return;
+			}
+			/*
+			 * If admission control is disabled we
+			 * try a little harder to let the task
+			 * run.
+			 */
+			cpu = cpumask_any(cpu_active_mask);
+		}
+		later_rq = cpu_rq(cpu);
+		double_lock_balance(rq, later_rq);
+	}
+
+	deactivate_task(rq, p, 0);
+	set_task_cpu(p, later_rq->cpu);
+	activate_task(later_rq, p, ENQUEUE_REPLENISH);
+
+	if (!fallback)
+		resched_curr(later_rq);
+
+	double_unlock_balance(rq, later_rq);
+}
+
 #else
 
 static inline
@@ -536,6 +584,17 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)
 	sched_clock_tick();
 	update_rq_clock(rq);
 
+#ifdef CONFIG_SMP
+	/*
+	 * So if we find that the rq the task was on is no longer
+	 * available, we need to select a new rq.
+	 */
+	if (unlikely(!rq->online)) {
+		dl_task_migration(rq, p);
+		goto unlock;
+	}
+#endif
+
 	/*
 	 * If the throttle happened during sched-out; like:
 	 *
-- 
1.9.1

Re: [PATCH v13] sched/deadline: support dl task migration during cpu hotplug

[Juri Lelli]

Hi,

On 25/03/2015 23:47, Wanpeng Li wrote:
> I observe that dl task can't be migrated to other cpus during cpu hotplug,
> in addition, task may/may not be running again if cpu is added back. The
> root cause which I found is that dl task will be throtted and removed from
> dl rq after comsuming all budget, which leads to stop task can't pick it up
> from dl rq and migrate to other cpus during hotplug.
> 
> The method to reproduce:
> schedtool -E -t 50000:100000 -e ./test
> Actually test is just a simple for loop. Then observe which cpu the test
> task is on.
> echo 0 > /sys/devices/system/cpu/cpuN/online
> 
> This patch adds the dl task migration during cpu hotplug by finding a most
> suitable later deadline rq after dl timer fire if current rq is offline,
> if fail to find a suitable later deadline rq then fallback to any eligible
> online cpu in order that the deadline task will come back to us, and the
> push/pull mechanism should then move it around properly.
> 
> Suggested-and-acked-by: Juri Lelli <juri.lelli@arm.com>
> Signed-off-by: Wanpeng Li <wanpeng.li@linux.intel.com>
> ---
> v12 -> 13:
>  * move hotplug stuff to CONFIG_SMP in order to fix the error reported by kbuild test robot
> v11 -> v12:
>  * s/WARN_ON/BUG_ON
> v10 -> v11:
>  * fix codes comments
>  * tsk_cpus_allowed(p) shouldn't be on separate lines
>  * introduce a helper function to fold dl task migration during cpu hotplug support
> v9 -> v10:
>  * fix the "WARNING: line over 80 characters"
>  * handle no admission control
> v8 -> v9:
>  * align tsk_cpus_allowed(p) to cpu_active_mask
>  * add WARN_ON(1)
>  * don't resched_curr if later_rq come from the cpumask_any_and()
> v7 -> v8:
>  * remove rd->span related modification since Pang's commit 16b269436b72
>    (sched/deadline: Modify cpudl::free_cpus to reflect rd->online) merged
>    upstream, which Juri pointed out can handle the exclusive cpusets.
>  * rebase
> v6 -> v7:
>  * rebase
> v5 -> v6:
>  * add double_lock_balance in the fallback path
> v4 -> v5:
>  * remove raw_spin_unlock(&rq->lock)
>  * cleanup codes, spotted by Peterz
>  * cleanup patch description
> v3 -> v4:
>  * use tsk_cpus_allowed wrapper
>  * fix compile error
> v2 -> v3:
>  * don't get_task_struct
>  * if cannot preempt any rq, fallback to pick any online cpus
>  * use cpu_active_mask as original later_mask if cpu is offline
> v1 -> v2:
>  * push the task to another cpu in dl_task_timer() if rq is offline.
> 
>  kernel/sched/deadline.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 59 insertions(+)
> 
> diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
> index 24c18dc..60b7e90 100644
> --- a/kernel/sched/deadline.c
> +++ b/kernel/sched/deadline.c
> @@ -218,6 +218,54 @@ static inline void set_post_schedule(struct rq *rq)
>  	rq->post_schedule = has_pushable_dl_tasks(rq);
>  }
>  
> +static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq);
> +
> +static void dl_task_migration(struct rq *rq, struct task_struct *p)
> +{
> +	struct rq *later_rq = NULL;
> +	bool fallback = false;
> +
> +	later_rq = find_lock_later_rq(p, rq);
> +
> +	if (!later_rq) {
> +		int cpu;
> +
> +		/*
> +		 * If we cannot preempt any rq, fall back to pick any
> +		 * online cpu.
> +		 */
> +		fallback = true;
> +		cpu = cpumask_any_and(cpu_active_mask, tsk_cpus_allowed(p));
> +		if (cpu >= nr_cpu_ids) {
> +			if (dl_bandwidth_enabled()) {
> +				/*
> +				 * Fail to find any suitable cpu.
> +				 * The task will never come back!
> +				 */
> +				BUG_ON(1);
> +				return;
> +			}
> +			/*
> +			 * If admission control is disabled we
> +			 * try a little harder to let the task
> +			 * run.
> +			 */
> +			cpu = cpumask_any(cpu_active_mask);
> +		}
> +		later_rq = cpu_rq(cpu);
> +		double_lock_balance(rq, later_rq);
> +	}
> +
> +	deactivate_task(rq, p, 0);
> +	set_task_cpu(p, later_rq->cpu);
> +	activate_task(later_rq, p, ENQUEUE_REPLENISH);
> +
> +	if (!fallback)
> +		resched_curr(later_rq);
> +
> +	double_unlock_balance(rq, later_rq);
> +}
> +
>  #else
>  
>  static inline
> @@ -536,6 +584,17 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)
>  	sched_clock_tick();
>  	update_rq_clock(rq);
>  
> +#ifdef CONFIG_SMP
> +	/*
> +	 * So if we find that the rq the task was on is no longer
> +	 * available, we need to select a new rq.
> +	 */
> +	if (unlikely(!rq->online)) {
> +		dl_task_migration(rq, p);
> +		goto unlock;
> +	}
> +#endif
> +
>  	/*
>  	 * If the throttle happened during sched-out; like:
>  	 *
> 

I think we could have better naming and the BUG_ON part could be
simplified. I'd propose something like this (sorry, it is based
on one of your previous versions.. I'm a bit struggling keeping
up with the pace ;)).

Thanks!

---
 kernel/sched/deadline.c | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
index 1820d1b..2b260a9 100644
--- a/kernel/sched/deadline.c
+++ b/kernel/sched/deadline.c
@@ -518,7 +518,7 @@ static int start_dl_timer(struct sched_dl_entity *dl_se, bool boosted)
 
 static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq);
 
-static void dl_task_migration(struct rq *rq, struct task_struct *p)
+static void dl_task_offline_migration(struct rq *rq, struct task_struct *p)
 {
 	struct rq *later_rq = NULL;
 	bool fallback = false;
@@ -535,14 +535,12 @@ static void dl_task_migration(struct rq *rq, struct task_struct *p)
 		fallback = true;
 		cpu = cpumask_any_and(cpu_active_mask, tsk_cpus_allowed(p));
 		if (cpu >= nr_cpu_ids) {
-			if (dl_bandwidth_enabled()) {
-				/*
-				 * Fail to find any suitable cpu.
-				 * The task will never come back!
-				 */
-				WARN_ON(1);
-				return;
-			}
+			/*
+			 * Fail to find any suitable cpu.
+			 * The task will never come back!
+			 */
+			BUG_ON(dl_bandwidth_enabled());
+
 			/*
 			 * If admission control is disabled we
 			 * try a little harder to let the task
@@ -609,11 +607,11 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)
 	update_rq_clock(rq);
 
 	/*
-	 * So if we find that the rq the task was on is no longer
+	 * If we find that the rq the task was on is no longer
 	 * available, we need to select a new rq.
 	 */
 	if (unlikely(!rq->online)) {
-		dl_task_migration(rq, p);
+		dl_task_offline_migration(rq, p);
 		goto unlock;
 	}
 
-- 
2.3.0

Re: [PATCH v13] sched/deadline: support dl task migration during cpu hotplug

[Wanpeng Li]

Hi Juri,
On Thu, Mar 26, 2015 at 11:14:37AM +0000, Juri Lelli wrote:
>
>I think we could have better naming and the BUG_ON part could be
>simplified. I'd propose something like this (sorry, it is based
>on one of your previous versions.. I'm a bit struggling keeping
>up with the pace ;)).

Cool, thanks for your help, I will send a newer version later. ;)

Regards,
Wanpeng Li 

>
>Thanks!
>
>---
> kernel/sched/deadline.c | 20 +++++++++-----------
> 1 file changed, 9 insertions(+), 11 deletions(-)
>
>diff --git a/kernel/sched/deadline.c b/kernel/sched/deadline.c
>index 1820d1b..2b260a9 100644
>--- a/kernel/sched/deadline.c
>+++ b/kernel/sched/deadline.c
>@@ -518,7 +518,7 @@ static int start_dl_timer(struct sched_dl_entity *dl_se, bool boosted)
> 
> static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq);
> 
>-static void dl_task_migration(struct rq *rq, struct task_struct *p)
>+static void dl_task_offline_migration(struct rq *rq, struct task_struct *p)
> {
> 	struct rq *later_rq = NULL;
> 	bool fallback = false;
>@@ -535,14 +535,12 @@ static void dl_task_migration(struct rq *rq, struct task_struct *p)
> 		fallback = true;
> 		cpu = cpumask_any_and(cpu_active_mask, tsk_cpus_allowed(p));
> 		if (cpu >= nr_cpu_ids) {
>-			if (dl_bandwidth_enabled()) {
>-				/*
>-				 * Fail to find any suitable cpu.
>-				 * The task will never come back!
>-				 */
>-				WARN_ON(1);
>-				return;
>-			}
>+			/*
>+			 * Fail to find any suitable cpu.
>+			 * The task will never come back!
>+			 */
>+			BUG_ON(dl_bandwidth_enabled());
>+
> 			/*
> 			 * If admission control is disabled we
> 			 * try a little harder to let the task
>@@ -609,11 +607,11 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)
> 	update_rq_clock(rq);
> 
> 	/*
>-	 * So if we find that the rq the task was on is no longer
>+	 * If we find that the rq the task was on is no longer
> 	 * available, we need to select a new rq.
> 	 */
> 	if (unlikely(!rq->online)) {
>-		dl_task_migration(rq, p);
>+		dl_task_offline_migration(rq, p);
> 		goto unlock;
> 	}
> 
>-- 
>2.3.0