cpuidle: Return nohz hint from cpuidle_select()

Add a new pointer argument to cpuidle_select() and to the ->select
cpuidle governor callback to allow a boolean value indicating
whether or not the tick should be stopped before entering the
selected state to be returned from there.

Make the ladder governor ignore that pointer (to preserve its
current behavior) and make the menu governor return 'false" through
it if:
 (1) the idle exit latency is constrained at 0, or
 (2) the selected state is a polling one, or
 (3) the expected idle period duration is within the tick period
     range.

In addition to that, the correction factor computations in the menu
governor need to take the possibility that the tick may not be
stopped into account to avoid artificially small correction factor
values.  To that end, add a mechanism to record tick wakeups, as
suggested by Peter Zijlstra, and use it to modify the menu_update()
behavior when tick wakeup occurs.  Namely, if the CPU is woken up by
the tick and the return value of tick_nohz_get_sleep_length() is not
within the tick boundary, the predicted idle duration is likely too
short, so make menu_update() try to compensate for that by updating
the governor statistics as though the CPU was idle for a long time.

Since the value returned through the new argument pointer of
cpuidle_select() is not used by its caller yet, this change by
itself is not expected to alter the functionality of the code.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>

diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index 0003e9a02637f1ded004d6465b4eaaeef5817821..6df894d65d9e270efe800ff0c371d8c775183f08 100644 (file)
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -272,12 +272,18 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv,
  *
  * @drv: the cpuidle driver
  * @dev: the cpuidle device
+ * @stop_tick: indication on whether or not to stop the tick
  *
  * Returns the index of the idle state.  The return value must not be negative.
+ *
+ * The memory location pointed to by @stop_tick is expected to be written the
+ * 'false' boolean value if the scheduler tick should not be stopped before
+ * entering the returned state.
  */
-int cpuidle_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
+int cpuidle_select(struct cpuidle_driver *drv, struct cpuidle_device *dev,
+                  bool *stop_tick)
 {
-       return cpuidle_curr_governor->select(drv, dev);
+       return cpuidle_curr_governor->select(drv, dev, stop_tick);
 }
 
 /**

diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c
index 1ad8745fd6d648321bcae1323c33f2ae549afcce..b24883f85c99543089d2035bfdf6226f589edb1b 100644 (file)
--- a/drivers/cpuidle/governors/ladder.c
+++ b/drivers/cpuidle/governors/ladder.c
@@ -63,9 +63,10 @@ static inline void ladder_do_selection(struct ladder_device *ldev,
  * ladder_select_state - selects the next state to enter
  * @drv: cpuidle driver
  * @dev: the CPU
+ * @dummy: not used
  */
 static int ladder_select_state(struct cpuidle_driver *drv,
-                               struct cpuidle_device *dev)
+                              struct cpuidle_device *dev, bool *dummy)
 {
        struct ladder_device *ldev = this_cpu_ptr(&ladder_devices);
        struct device *device = get_cpu_device(dev->cpu);

diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index aa390404e85f132705e4ca80506d15d292469c7e..f53a929bd2bdbaf5f204b326237ffb7fc714edcd 100644 (file)
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -123,6 +123,7 @@
 struct menu_device {
        int             last_state_idx;
        int             needs_update;
+       int             tick_wakeup;
 
        unsigned int    next_timer_us;
        unsigned int    predicted_us;
@@ -279,8 +280,10 @@ again:
  * menu_select - selects the next idle state to enter
  * @drv: cpuidle driver containing state data
  * @dev: the CPU
+ * @stop_tick: indication on whether or not to stop the tick
  */
-static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
+static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev,
+                      bool *stop_tick)
 {
        struct menu_device *data = this_cpu_ptr(&menu_devices);
        struct device *device = get_cpu_device(dev->cpu);
@@ -303,8 +306,10 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
                latency_req = resume_latency;
 
        /* Special case when user has set very strict latency requirement */
-       if (unlikely(latency_req == 0))
+       if (unlikely(latency_req == 0)) {
+               *stop_tick = false;
                return 0;
+       }
 
        /* determine the expected residency time, round up */
        data->next_timer_us = ktime_to_us(tick_nohz_get_sleep_length());
@@ -354,6 +359,7 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
        if (latency_req > interactivity_req)
                latency_req = interactivity_req;
 
+       expected_interval = data->predicted_us;
        /*
         * Find the idle state with the lowest power while satisfying
         * our constraints.
@@ -369,15 +375,30 @@ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
                        idx = i; /* first enabled state */
                if (s->target_residency > data->predicted_us)
                        break;
-               if (s->exit_latency > latency_req)
+               if (s->exit_latency > latency_req) {
+                       /*
+                        * If we break out of the loop for latency reasons, use
+                        * the target residency of the selected state as the
+                        * expected idle duration so that the tick is retained
+                        * as long as that target residency is low enough.
+                        */
+                       expected_interval = drv->states[idx].target_residency;
                        break;
-
+               }
                idx = i;
        }
 
        if (idx == -1)
                idx = 0; /* No states enabled. Must use 0. */
 
+       /*
+        * Don't stop the tick if the selected state is a polling one or if the
+        * expected idle duration is shorter than the tick period length.
+        */
+       if ((drv->states[idx].flags & CPUIDLE_FLAG_POLLING) ||
+           expected_interval < TICK_USEC)
+               *stop_tick = false;
+
        data->last_state_idx = idx;
 
        return data->last_state_idx;
@@ -397,6 +418,7 @@ static void menu_reflect(struct cpuidle_device *dev, int index)
 
        data->last_state_idx = index;
        data->needs_update = 1;
+       data->tick_wakeup = tick_nohz_idle_got_tick();
 }
 
 /**
@@ -427,14 +449,27 @@ static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
         * assume the state was never reached and the exit latency is 0.
         */
 
-       /* measured value */
-       measured_us = cpuidle_get_last_residency(dev);
-
-       /* Deduct exit latency */
-       if (measured_us > 2 * target->exit_latency)
-               measured_us -= target->exit_latency;
-       else
-               measured_us /= 2;
+       if (data->tick_wakeup && data->next_timer_us > TICK_USEC) {
+               /*
+                * The nohz code said that there wouldn't be any events within
+                * the tick boundary (if the tick was stopped), but the idle
+                * duration predictor had a differing opinion.  Since the CPU
+                * was woken up by a tick (that wasn't stopped after all), the
+                * predictor was not quite right, so assume that the CPU could
+                * have been idle long (but not forever) to help the idle
+                * duration predictor do a better job next time.
+                */
+               measured_us = 9 * MAX_INTERESTING / 10;
+       } else {
+               /* measured value */
+               measured_us = cpuidle_get_last_residency(dev);
+
+               /* Deduct exit latency */
+               if (measured_us > 2 * target->exit_latency)
+                       measured_us -= target->exit_latency;
+               else
+                       measured_us /= 2;
+       }
 
        /* Make sure our coefficients do not exceed unity */
        if (measured_us > data->next_timer_us)

diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index a806e94c482f98805ee6a68d3f9a8055f5ca77b2..1eefabf1621f40bd9269804c35bebbc539747515 100644 (file)
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -135,7 +135,8 @@ extern bool cpuidle_not_available(struct cpuidle_driver *drv,
                                  struct cpuidle_device *dev);
 
 extern int cpuidle_select(struct cpuidle_driver *drv,
-                         struct cpuidle_device *dev);
+                         struct cpuidle_device *dev,
+                         bool *stop_tick);
 extern int cpuidle_enter(struct cpuidle_driver *drv,
                         struct cpuidle_device *dev, int index);
 extern void cpuidle_reflect(struct cpuidle_device *dev, int index);
@@ -167,7 +168,7 @@ static inline bool cpuidle_not_available(struct cpuidle_driver *drv,
                                         struct cpuidle_device *dev)
 {return true; }
 static inline int cpuidle_select(struct cpuidle_driver *drv,
-                                struct cpuidle_device *dev)
+                                struct cpuidle_device *dev, bool *stop_tick)
 {return -ENODEV; }
 static inline int cpuidle_enter(struct cpuidle_driver *drv,
                                struct cpuidle_device *dev, int index)
@@ -250,7 +251,8 @@ struct cpuidle_governor {
                                        struct cpuidle_device *dev);
 
        int  (*select)          (struct cpuidle_driver *drv,
-                                       struct cpuidle_device *dev);
+                                       struct cpuidle_device *dev,
+                                       bool *stop_tick);
        void (*reflect)         (struct cpuidle_device *dev, int index);
 };
 

diff --git a/include/linux/tick.h b/include/linux/tick.h
index fccebfba167ebe44f130e45ee9112ee73496b7e2..ef0717e5e526666be984615f936ff00e8b8ef2d1 100644 (file)
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -120,6 +120,7 @@ extern void tick_nohz_idle_restart_tick(void);
 extern void tick_nohz_idle_enter(void);
 extern void tick_nohz_idle_exit(void);
 extern void tick_nohz_irq_exit(void);
+extern bool tick_nohz_idle_got_tick(void);
 extern ktime_t tick_nohz_get_sleep_length(void);
 extern unsigned long tick_nohz_get_idle_calls(void);
 extern unsigned long tick_nohz_get_idle_calls_cpu(int cpu);
@@ -141,6 +142,7 @@ static inline void tick_nohz_idle_stop_tick(void) { }
 static inline void tick_nohz_idle_restart_tick(void) { }
 static inline void tick_nohz_idle_enter(void) { }
 static inline void tick_nohz_idle_exit(void) { }
+static inline bool tick_nohz_idle_got_tick(void) { return false; }
 
 static inline ktime_t tick_nohz_get_sleep_length(void)
 {

diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c
index 4f64835d38a847ca0c57d9e5c09e182246eb2ecd..a966bd2a6fa0f5a1ee515bcf679e18ad2e2b75bd 100644 (file)
--- a/kernel/sched/idle.c
+++ b/kernel/sched/idle.c
@@ -183,13 +183,15 @@ static void cpuidle_idle_call(void)
                next_state = cpuidle_find_deepest_state(drv, dev);
                call_cpuidle(drv, dev, next_state);
        } else {
+               bool stop_tick = true;
+
                tick_nohz_idle_stop_tick();
                rcu_idle_enter();
 
                /*
                 * Ask the cpuidle framework to choose a convenient idle state.
                 */
-               next_state = cpuidle_select(drv, dev);
+               next_state = cpuidle_select(drv, dev, &stop_tick);
                entered_state = call_cpuidle(drv, dev, next_state);
                /*
                 * Give the governor an opportunity to reflect on the outcome

diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index f5d37788ea85cc1224abf360425c9db4ea280ace..69fe113cfc7f02e0f2a1db492af77da5e003ae45 100644 (file)
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -966,6 +966,20 @@ void tick_nohz_irq_exit(void)
                tick_nohz_full_update_tick(ts);
 }
 
+/**
+ * tick_nohz_idle_got_tick - Check whether or not the tick handler has run
+ */
+bool tick_nohz_idle_got_tick(void)
+{
+       struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
+
+       if (ts->inidle > 1) {
+               ts->inidle = 1;
+               return true;
+       }
+       return false;
+}
+
 /**
  * tick_nohz_get_sleep_length - return the length of the current sleep
  *
@@ -1077,6 +1091,9 @@ static void tick_nohz_handler(struct clock_event_device *dev)
        struct pt_regs *regs = get_irq_regs();
        ktime_t now = ktime_get();
 
+       if (ts->inidle)
+               ts->inidle = 2;
+
        dev->next_event = KTIME_MAX;
 
        tick_sched_do_timer(now);
@@ -1174,6 +1191,9 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
        struct pt_regs *regs = get_irq_regs();
        ktime_t now = ktime_get();
 
+       if (ts->inidle)
+               ts->inidle = 2;
+
        tick_sched_do_timer(now);
 
        /*