| Message ID | 1392131491-5265-5-git-send-email-daniel.lezcano@linaro.org |
|---|---|
| State | New |
| Headers | show |
On Tue, 11 Feb 2014, Daniel Lezcano wrote: > The idle main function is a complex and a critical function. Added more > comments to the code. > > Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org> Few questions below. In any case,: Acked-by: Nicolas Pitre <nico@linaro.org> > --- > kernel/sched/idle.c | 37 +++++++++++++++++++++++++++++++++---- > 1 file changed, 33 insertions(+), 4 deletions(-) > > diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c > index 72b5926..36ff1a7 100644 > --- a/kernel/sched/idle.c > +++ b/kernel/sched/idle.c > @@ -86,19 +86,34 @@ static int cpuidle_idle_call(void) > if (cpu_idle_force_poll || tick_check_broadcast_expired()) > return cpu_idle_poll(); > > + /* > + * Check if the idle task must rescheduled. If it is the case, s/must/must be/ > + * exit the function after re-enabling the local irq and set > + * again the polling flag > + */ > if (current_clr_polling_and_test()) { > local_irq_enable(); > __current_set_polling(); > return 0; > } > > + /* > + * During the idle period, stop measuring the disabled irqs > + * critical sections latencies > + */ > stop_critical_timings(); > + > + /* > + * Tell the RCU framework we are entering an idle section, > + * so no more rcu read side critical sections and one more > + * step to the grace period > + */ > rcu_idle_enter(); > > - /* Ask the governor for the next state, this call can fail for > - * different reasons: cpuidle is not enabled or an idle state > - * fulfilling the constraints was not found. In this case, we fall > - * back to the default idle function > + /* > + * Ask the governor to choose an idle state it thinks it is > + * convenient to go to. There is *always* a convenient idle > + * state but the call could fail if cpuidle is not enabled > */ > next_state = cpuidle_select(drv, dev); > if (next_state < 0) { > @@ -106,6 +121,10 @@ static int cpuidle_idle_call(void) > goto out; > } > > + /* > + * The idle task must be scheduled, it is pointless to go to idle, > + * just update no idle residency and get out of this function > + */ > if (need_resched()) { > dev->last_residency = 0; > /* give the governor an opportunity to reflect on the outcome */ Is this if block really necessary? We already have need_resched() being monitored in the outer loop. Are cpuidle_select() or rcu_idle_enter() likely to spend a significant amount of time justifying a recheck here? Nicolas -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
On 02/11/2014 06:51 PM, Nicolas Pitre wrote: > On Tue, 11 Feb 2014, Daniel Lezcano wrote: > >> The idle main function is a complex and a critical function. Added more >> comments to the code. >> >> Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org> > > Few questions below. In any case,: > > Acked-by: Nicolas Pitre <nico@linaro.org> Thanks for the review Nico ! Answer below. >> --- >> kernel/sched/idle.c | 37 +++++++++++++++++++++++++++++++++---- >> 1 file changed, 33 insertions(+), 4 deletions(-) >> >> diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c >> index 72b5926..36ff1a7 100644 >> --- a/kernel/sched/idle.c >> +++ b/kernel/sched/idle.c >> @@ -86,19 +86,34 @@ static int cpuidle_idle_call(void) >> if (cpu_idle_force_poll || tick_check_broadcast_expired()) >> return cpu_idle_poll(); >> >> + /* >> + * Check if the idle task must rescheduled. If it is the case, > > s/must/must be/ > >> + * exit the function after re-enabling the local irq and set >> + * again the polling flag >> + */ >> if (current_clr_polling_and_test()) { >> local_irq_enable(); >> __current_set_polling(); >> return 0; >> } >> >> + /* >> + * During the idle period, stop measuring the disabled irqs >> + * critical sections latencies >> + */ >> stop_critical_timings(); >> + >> + /* >> + * Tell the RCU framework we are entering an idle section, >> + * so no more rcu read side critical sections and one more >> + * step to the grace period >> + */ >> rcu_idle_enter(); >> >> - /* Ask the governor for the next state, this call can fail for >> - * different reasons: cpuidle is not enabled or an idle state >> - * fulfilling the constraints was not found. In this case, we fall >> - * back to the default idle function >> + /* >> + * Ask the governor to choose an idle state it thinks it is >> + * convenient to go to. There is *always* a convenient idle >> + * state but the call could fail if cpuidle is not enabled >> */ >> next_state = cpuidle_select(drv, dev); >> if (next_state < 0) { >> @@ -106,6 +121,10 @@ static int cpuidle_idle_call(void) >> goto out; >> } >> >> + /* >> + * The idle task must be scheduled, it is pointless to go to idle, >> + * just update no idle residency and get out of this function >> + */ >> if (need_resched()) { >> dev->last_residency = 0; >> /* give the governor an opportunity to reflect on the outcome */ > > Is this if block really necessary? We already have need_resched() being > monitored in the outer loop. Are cpuidle_select() or rcu_idle_enter() > likely to spend a significant amount of time justifying a recheck here? That's a question I have been always asking myself. The cpuidle_select function could spend some time for: 1. reflecting the idle time for the statistics of the previous idle period. This processing is post-poned when exiting an idle state via the 'need_update' field in the cpuidle structure. I guess, this is because it can take a while and we want to exit asap to reduce the wakeup latency. 2. there are some processing to choose the idle state. I don't know what is the rational here to use need_resched at this place except to 'abort' an idle state arbitrarily after some experimentation for better reactivity. I am wondering if the multiple need_resched() we find in the call stack for some idle states makes really sense and doesn't denote a lack of control of what is happening in the idle path vs system activity or a lack of confidence in the idle duration prediction.
diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c index 72b5926..36ff1a7 100644 --- a/kernel/sched/idle.c +++ b/kernel/sched/idle.c @@ -86,19 +86,34 @@ static int cpuidle_idle_call(void) if (cpu_idle_force_poll || tick_check_broadcast_expired()) return cpu_idle_poll(); + /* + * Check if the idle task must rescheduled. If it is the case, + * exit the function after re-enabling the local irq and set + * again the polling flag + */ if (current_clr_polling_and_test()) { local_irq_enable(); __current_set_polling(); return 0; } + /* + * During the idle period, stop measuring the disabled irqs + * critical sections latencies + */ stop_critical_timings(); + + /* + * Tell the RCU framework we are entering an idle section, + * so no more rcu read side critical sections and one more + * step to the grace period + */ rcu_idle_enter(); - /* Ask the governor for the next state, this call can fail for - * different reasons: cpuidle is not enabled or an idle state - * fulfilling the constraints was not found. In this case, we fall - * back to the default idle function + /* + * Ask the governor to choose an idle state it thinks it is + * convenient to go to. There is *always* a convenient idle + * state but the call could fail if cpuidle is not enabled */ next_state = cpuidle_select(drv, dev); if (next_state < 0) { @@ -106,6 +121,10 @@ static int cpuidle_idle_call(void) goto out; } + /* + * The idle task must be scheduled, it is pointless to go to idle, + * just update no idle residency and get out of this function + */ if (need_resched()) { dev->last_residency = 0; /* give the governor an opportunity to reflect on the outcome */ @@ -116,6 +135,12 @@ static int cpuidle_idle_call(void) trace_cpu_idle_rcuidle(next_state, dev->cpu); + /* + * Enter the idle state previously returned by the governor + * decision. This function will block until an interrupt + * occurs and will take care of re-enabling the local + * interrupts + */ entered_state = cpuidle_enter(drv, dev, next_state); trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, dev->cpu); @@ -152,6 +177,10 @@ static void cpu_idle_loop(void) local_irq_disable(); arch_cpu_idle_enter(); + /* + * It is up to the underlying functions to + * enable the local interrupts again + */ cpuidle_idle_call(); arch_cpu_idle_exit();
The idle main function is a complex and a critical function. Added more comments to the code. Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org> --- kernel/sched/idle.c | 37 +++++++++++++++++++++++++++++++++---- 1 file changed, 33 insertions(+), 4 deletions(-)