From: "Joel Fernandes (Google)" <[email protected]>
RCU tasks callbacks can take atleast 1 second before the callbacks are
executed. This happens even if the hold-out tasks enter their quiescent states
quickly. I noticed this when I was testing trampoline callback execution.
To test the trampoline freeing, I wrote a simple script:
cd /sys/kernel/debug/tracing/
echo '__schedule_bug:traceon' > set_ftrace_filter;
echo '!__schedule_bug:traceon' > set_ftrace_filter;
In the background I had simple bash while loop:
while [ 1 ]; do x=1; done &
Total time of completion of above commands in seconds:
With this patch:
real 0m0.179s
user 0m0.000s
sys 0m0.054s
Without this patch:
real 0m1.098s
user 0m0.000s
sys 0m0.053s
That's a great than 6X speed up in performance. In order to accomplish
this, I am waiting for HZ/10 time before entering the hold-out checking
loop. The loop still preserves its checking of held tasks every 1 second
as before, incase this first test doesn't succeed.
Cc: Steven Rostedt <[email protected]>
Cc: Peter Zilstra <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Boqun Feng <[email protected]>
Cc: Paul McKenney <[email protected]>
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Joel Fernandes (Google) <[email protected]>
---
Changes since v1->v2:
- Changed total wait time to HZ/10 instead of 2 jiffies
- Updated the commands to reproduce issue
kernel/rcu/update.c | 12 +++++++++++-
1 file changed, 11 insertions(+), 1 deletion(-)
diff --git a/kernel/rcu/update.c b/kernel/rcu/update.c
index 5783bdf86e5a..a28698e44b08 100644
--- a/kernel/rcu/update.c
+++ b/kernel/rcu/update.c
@@ -743,6 +743,12 @@ static int __noreturn rcu_tasks_kthread(void *arg)
*/
synchronize_srcu(&tasks_rcu_exit_srcu);
+ /*
+ * Wait a little bit incase held tasks are released
+ * during their next timer ticks.
+ */
+ schedule_timeout_interruptible(HZ/10);
+
/*
* Each pass through the following loop scans the list
* of holdout tasks, removing any that are no longer
@@ -755,7 +761,6 @@ static int __noreturn rcu_tasks_kthread(void *arg)
int rtst;
struct task_struct *t1;
- schedule_timeout_interruptible(HZ);
rtst = READ_ONCE(rcu_task_stall_timeout);
needreport = rtst > 0 &&
time_after(jiffies, lastreport + rtst);
@@ -768,6 +773,11 @@ static int __noreturn rcu_tasks_kthread(void *arg)
check_holdout_task(t, needreport, &firstreport);
cond_resched();
}
+
+ if (list_empty(&rcu_tasks_holdouts))
+ break;
+
+ schedule_timeout_interruptible(HZ);
}
/*
--
2.17.0.441.gb46fe60e1d-goog
On Sun, May 20, 2018 at 05:43:24PM -0700, Joel Fernandes wrote:
> From: "Joel Fernandes (Google)" <[email protected]>
>
> RCU tasks callbacks can take atleast 1 second before the callbacks are
> executed. This happens even if the hold-out tasks enter their quiescent states
> quickly. I noticed this when I was testing trampoline callback execution.
>
> To test the trampoline freeing, I wrote a simple script:
> cd /sys/kernel/debug/tracing/
> echo '__schedule_bug:traceon' > set_ftrace_filter;
> echo '!__schedule_bug:traceon' > set_ftrace_filter;
>
> In the background I had simple bash while loop:
> while [ 1 ]; do x=1; done &
>
> Total time of completion of above commands in seconds:
>
> With this patch:
> real 0m0.179s
> user 0m0.000s
> sys 0m0.054s
>
> Without this patch:
> real 0m1.098s
> user 0m0.000s
> sys 0m0.053s
>
> That's a great than 6X speed up in performance. In order to accomplish
> this, I am waiting for HZ/10 time before entering the hold-out checking
> loop. The loop still preserves its checking of held tasks every 1 second
> as before, incase this first test doesn't succeed.
>
> Cc: Steven Rostedt <[email protected]>
Seems straightforward enough. The commit log needs a bit of cleanup
("atleast", "great than", ...).
Steve, thoughts? Any reason why this would be a problem?
Thanx, Paul
> Cc: Peter Zilstra <[email protected]>
> Cc: Ingo Molnar <[email protected]>
> Cc: Boqun Feng <[email protected]>
> Cc: Paul McKenney <[email protected]>
> Cc: [email protected]
> Cc: [email protected]
> Signed-off-by: Joel Fernandes (Google) <[email protected]>
> ---
> Changes since v1->v2:
> - Changed total wait time to HZ/10 instead of 2 jiffies
> - Updated the commands to reproduce issue
>
> kernel/rcu/update.c | 12 +++++++++++-
> 1 file changed, 11 insertions(+), 1 deletion(-)
>
> diff --git a/kernel/rcu/update.c b/kernel/rcu/update.c
> index 5783bdf86e5a..a28698e44b08 100644
> --- a/kernel/rcu/update.c
> +++ b/kernel/rcu/update.c
> @@ -743,6 +743,12 @@ static int __noreturn rcu_tasks_kthread(void *arg)
> */
> synchronize_srcu(&tasks_rcu_exit_srcu);
>
> + /*
> + * Wait a little bit incase held tasks are released
> + * during their next timer ticks.
> + */
> + schedule_timeout_interruptible(HZ/10);
> +
> /*
> * Each pass through the following loop scans the list
> * of holdout tasks, removing any that are no longer
> @@ -755,7 +761,6 @@ static int __noreturn rcu_tasks_kthread(void *arg)
> int rtst;
> struct task_struct *t1;
>
> - schedule_timeout_interruptible(HZ);
> rtst = READ_ONCE(rcu_task_stall_timeout);
> needreport = rtst > 0 &&
> time_after(jiffies, lastreport + rtst);
> @@ -768,6 +773,11 @@ static int __noreturn rcu_tasks_kthread(void *arg)
> check_holdout_task(t, needreport, &firstreport);
> cond_resched();
> }
> +
> + if (list_empty(&rcu_tasks_holdouts))
> + break;
> +
> + schedule_timeout_interruptible(HZ);
> }
>
> /*
> --
> 2.17.0.441.gb46fe60e1d-goog
>