[PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Rafael J. Wysocki]

From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

If freeze_enter() is called, we want to bypass the current cpuidle
governor and always use the deepest available (that is, not disabled)
C-state, because we want to save as much energy as reasonably possible
then and runtime latency constraints don't matter at that point, since
the system is in a sleep state anyway.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
---

This is on top of https://patchwork.kernel.org/patch/4071541/ .

---
 drivers/cpuidle/cpuidle.c |   45 ++++++++++++++++++++++++++++++++++++++++++++-
 include/linux/cpuidle.h   |    2 ++
 kernel/power/suspend.c    |    2 ++
 3 files changed, 48 insertions(+), 1 deletion(-)

Index: linux-pm/drivers/cpuidle/cpuidle.c
===================================================================
--- linux-pm.orig/drivers/cpuidle/cpuidle.c
+++ linux-pm/drivers/cpuidle/cpuidle.c
@@ -32,6 +32,7 @@ LIST_HEAD(cpuidle_detected_devices);
 static int enabled_devices;
 static int off __read_mostly;
 static int initialized __read_mostly;
+static bool use_deepest_state __read_mostly;
 
 int cpuidle_disabled(void)
 {
@@ -65,6 +66,45 @@ int cpuidle_play_dead(void)
 }
 
 /**
+ * cpuidle_use_deepest_state - Enable/disable the "deepest idle" mode.
+ * @enable: Whether enable or disable the feature.
+ *
+ * If the "deepest idle" mode is enabled, cpuidle will ignore the governor and
+ * always use the state with the greatest exit latency (out of the states that
+ * are not disabled).
+ *
+ * This function can only be called after cpuidle_pause() to avoid races.
+ */
+void cpuidle_use_deepest_state(bool enable)
+{
+	use_deepest_state = enable;
+}
+
+/**
+ * cpuidle_find_deepest_state - Find the state of the greatest exit latency.
+ * @drv: cpuidle driver for a given CPU.
+ * @dev: cpuidle device for a given CPU.
+ */
+static int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
+				      struct cpuidle_device *dev)
+{
+	unsigned int latency_req = 0;
+	int i, ret = CPUIDLE_DRIVER_STATE_START - 1;
+
+	for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) {
+		struct cpuidle_state *s = &drv->states[i];
+		struct cpuidle_state_usage *su = &dev->states_usage[i];
+
+		if (s->disabled || su->disable || s->exit_latency <= latency_req)
+			continue;
+
+		latency_req = s->exit_latency;
+		ret = i;
+	}
+	return ret;
+}
+
+/**
  * cpuidle_enter_state - enter the state and update stats
  * @dev: cpuidle device for this cpu
  * @drv: cpuidle driver for this cpu
@@ -124,6 +164,9 @@ int cpuidle_select(struct cpuidle_driver
 	if (!drv || !dev || !dev->enabled)
 		return -EBUSY;
 
+	if (unlikely(use_deepest_state))
+		return cpuidle_find_deepest_state(drv, dev);
+
 	return cpuidle_curr_governor->select(drv, dev);
 }
 
@@ -155,7 +198,7 @@ int cpuidle_enter(struct cpuidle_driver
  */
 void cpuidle_reflect(struct cpuidle_device *dev, int index)
 {
-	if (cpuidle_curr_governor->reflect)
+	if (cpuidle_curr_governor->reflect && !unlikely(use_deepest_state))
 		cpuidle_curr_governor->reflect(dev, index);
 }
 
Index: linux-pm/include/linux/cpuidle.h
===================================================================
--- linux-pm.orig/include/linux/cpuidle.h
+++ linux-pm/include/linux/cpuidle.h
@@ -143,6 +143,7 @@ extern void cpuidle_resume(void);
 extern int cpuidle_enable_device(struct cpuidle_device *dev);
 extern void cpuidle_disable_device(struct cpuidle_device *dev);
 extern int cpuidle_play_dead(void);
+extern void cpuidle_use_deepest_state(bool enable);
 
 extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
 #else
@@ -175,6 +176,7 @@ static inline int cpuidle_enable_device(
 {return -ENODEV; }
 static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
 static inline int cpuidle_play_dead(void) {return -ENODEV; }
+static inline void cpuidle_use_deepest_state(bool enable) {}
 static inline struct cpuidle_driver *cpuidle_get_cpu_driver(
 	struct cpuidle_device *dev) {return NULL; }
 #endif
Index: linux-pm/kernel/power/suspend.c
===================================================================
--- linux-pm.orig/kernel/power/suspend.c
+++ linux-pm/kernel/power/suspend.c
@@ -54,9 +54,11 @@ static void freeze_begin(void)
 
 static void freeze_enter(void)
 {
+	cpuidle_use_deepest_state(true);
 	cpuidle_resume();
 	wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
 	cpuidle_pause();
+	cpuidle_use_deepest_state(false);
 }
 
 void freeze_wake(void)

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Li, Aubrey]

On 2014/5/5 6:51, Rafael J. Wysocki wrote:
> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> 
> If freeze_enter() is called, we want to bypass the current cpuidle
> governor and always use the deepest available (that is, not disabled)
> C-state, because we want to save as much energy as reasonably possible
> then and runtime latency constraints don't matter at that point, since
> the system is in a sleep state anyway.
> 
> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> ---
> 
> This is on top of https://patchwork.kernel.org/patch/4071541/ .
> 
> ---
>  drivers/cpuidle/cpuidle.c |   45 ++++++++++++++++++++++++++++++++++++++++++++-
>  include/linux/cpuidle.h   |    2 ++
>  kernel/power/suspend.c    |    2 ++
>  3 files changed, 48 insertions(+), 1 deletion(-)
> 
> Index: linux-pm/drivers/cpuidle/cpuidle.c
> ===================================================================
> --- linux-pm.orig/drivers/cpuidle/cpuidle.c
> +++ linux-pm/drivers/cpuidle/cpuidle.c
> @@ -32,6 +32,7 @@ LIST_HEAD(cpuidle_detected_devices);
>  static int enabled_devices;
>  static int off __read_mostly;
>  static int initialized __read_mostly;
> +static bool use_deepest_state __read_mostly;
>  
>  int cpuidle_disabled(void)
>  {
> @@ -65,6 +66,45 @@ int cpuidle_play_dead(void)
>  }
>  
>  /**
> + * cpuidle_use_deepest_state - Enable/disable the "deepest idle" mode.
> + * @enable: Whether enable or disable the feature.
> + *
> + * If the "deepest idle" mode is enabled, cpuidle will ignore the governor and
> + * always use the state with the greatest exit latency (out of the states that
> + * are not disabled).
> + *
> + * This function can only be called after cpuidle_pause() to avoid races.
> + */
> +void cpuidle_use_deepest_state(bool enable)
> +{
> +	use_deepest_state = enable;
> +}
> +
> +/**
> + * cpuidle_find_deepest_state - Find the state of the greatest exit latency.
> + * @drv: cpuidle driver for a given CPU.
> + * @dev: cpuidle device for a given CPU.
> + */
> +static int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
> +				      struct cpuidle_device *dev)
> +{
> +	unsigned int latency_req = 0;
> +	int i, ret = CPUIDLE_DRIVER_STATE_START - 1;
> +
> +	for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) {
> +		struct cpuidle_state *s = &drv->states[i];
> +		struct cpuidle_state_usage *su = &dev->states_usage[i];
> +
> +		if (s->disabled || su->disable || s->exit_latency <= latency_req)
> +			continue;
> +
> +		latency_req = s->exit_latency;
> +		ret = i;
> +	}
> +	return ret;
> +}
> +
> +/**
>   * cpuidle_enter_state - enter the state and update stats
>   * @dev: cpuidle device for this cpu
>   * @drv: cpuidle driver for this cpu
> @@ -124,6 +164,9 @@ int cpuidle_select(struct cpuidle_driver
>  	if (!drv || !dev || !dev->enabled)
>  		return -EBUSY;
>  
> +	if (unlikely(use_deepest_state))
> +		return cpuidle_find_deepest_state(drv, dev);
> +
>  	return cpuidle_curr_governor->select(drv, dev);
>  }
>  
> @@ -155,7 +198,7 @@ int cpuidle_enter(struct cpuidle_driver
>   */
>  void cpuidle_reflect(struct cpuidle_device *dev, int index)
>  {
> -	if (cpuidle_curr_governor->reflect)
> +	if (cpuidle_curr_governor->reflect && !unlikely(use_deepest_state))
>  		cpuidle_curr_governor->reflect(dev, index);
>  }
>  
> Index: linux-pm/include/linux/cpuidle.h
> ===================================================================
> --- linux-pm.orig/include/linux/cpuidle.h
> +++ linux-pm/include/linux/cpuidle.h
> @@ -143,6 +143,7 @@ extern void cpuidle_resume(void);
>  extern int cpuidle_enable_device(struct cpuidle_device *dev);
>  extern void cpuidle_disable_device(struct cpuidle_device *dev);
>  extern int cpuidle_play_dead(void);
> +extern void cpuidle_use_deepest_state(bool enable);
>  
>  extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
>  #else
> @@ -175,6 +176,7 @@ static inline int cpuidle_enable_device(
>  {return -ENODEV; }
>  static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
>  static inline int cpuidle_play_dead(void) {return -ENODEV; }
> +static inline void cpuidle_use_deepest_state(bool enable) {}
>  static inline struct cpuidle_driver *cpuidle_get_cpu_driver(
>  	struct cpuidle_device *dev) {return NULL; }
>  #endif
> Index: linux-pm/kernel/power/suspend.c
> ===================================================================
> --- linux-pm.orig/kernel/power/suspend.c
> +++ linux-pm/kernel/power/suspend.c
> @@ -54,9 +54,11 @@ static void freeze_begin(void)
>  
>  static void freeze_enter(void)
>  {
> +	cpuidle_use_deepest_state(true);
>  	cpuidle_resume();
>  	wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
>  	cpuidle_pause();
> +	cpuidle_use_deepest_state(false);
>  }
>  
>  void freeze_wake(void)
> 

Tested-by: Aubrey Li <aubrey.li@linux.intel.com>

I tested freeze mode on ASUS-T100, it works as expected. Thanks Rafael!

-Aubrey

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Pavel Machek]

On Mon 2014-05-05 00:51:54, Rafael J. Wysocki wrote:
> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> 
> If freeze_enter() is called, we want to bypass the current cpuidle
> governor and always use the deepest available (that is, not disabled)
> C-state, because we want to save as much energy as reasonably possible
> then and runtime latency constraints don't matter at that point, since
> the system is in a sleep state anyway.

Would there be way to pass the parameter "go to deepest" instead of adding
global state for this?
								Pavel

> Index: linux-pm/kernel/power/suspend.c
> ===================================================================
> --- linux-pm.orig/kernel/power/suspend.c
> +++ linux-pm/kernel/power/suspend.c
> @@ -54,9 +54,11 @@ static void freeze_begin(void)
>  
>  static void freeze_enter(void)
>  {
> +	cpuidle_use_deepest_state(true);
>  	cpuidle_resume();
>  	wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
>  	cpuidle_pause();
> +	cpuidle_use_deepest_state(false);
>  }
>  
>  void freeze_wake(void)
> 
> --
> 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/

-- 
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Rafael J. Wysocki]

On Friday, May 09, 2014 09:38:35 AM Pavel Machek wrote:
> On Mon 2014-05-05 00:51:54, Rafael J. Wysocki wrote:
> > From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> > 
> > If freeze_enter() is called, we want to bypass the current cpuidle
> > governor and always use the deepest available (that is, not disabled)
> > C-state, because we want to save as much energy as reasonably possible
> > then and runtime latency constraints don't matter at that point, since
> > the system is in a sleep state anyway.
> 
> Would there be way to pass the parameter "go to deepest" instead of adding
> global state for this?

I'm not sure what you mean?  A parameter of what in particular?  And where
to pass it?

Rafael

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Pavel Machek]

On Fri 2014-05-09 13:26:47, Rafael J. Wysocki wrote:
> On Friday, May 09, 2014 09:38:35 AM Pavel Machek wrote:
> > On Mon 2014-05-05 00:51:54, Rafael J. Wysocki wrote:
> > > From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> > > 
> > > If freeze_enter() is called, we want to bypass the current cpuidle
> > > governor and always use the deepest available (that is, not disabled)
> > > C-state, because we want to save as much energy as reasonably possible
> > > then and runtime latency constraints don't matter at that point, since
> > > the system is in a sleep state anyway.
> > 
> > Would there be way to pass the parameter "go to deepest" instead of adding
> > global state for this?
> 
> I'm not sure what you mean?  A parameter of what in particular?  And where
> to pass it?

Currently the code is:

static void freeze_enter(void)
{
+ cpuidle_use_deepest_state(true);
  cpuidle_resume();
  wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
  cpuidle_pause();
+ cpuidle_use_deepest_state(false);
}

. I believe it would be better if you did

cpuidle_resume(GOTO_DEEPEST_C_STATE)

instead of having global state.

Thanks,
										Pavel
-- 
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Rafael J. Wysocki]

On Friday, May 09, 2014 04:13:56 PM Pavel Machek wrote:
> On Fri 2014-05-09 13:26:47, Rafael J. Wysocki wrote:
> > On Friday, May 09, 2014 09:38:35 AM Pavel Machek wrote:
> > > On Mon 2014-05-05 00:51:54, Rafael J. Wysocki wrote:
> > > > From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> > > > 
> > > > If freeze_enter() is called, we want to bypass the current cpuidle
> > > > governor and always use the deepest available (that is, not disabled)
> > > > C-state, because we want to save as much energy as reasonably possible
> > > > then and runtime latency constraints don't matter at that point, since
> > > > the system is in a sleep state anyway.
> > > 
> > > Would there be way to pass the parameter "go to deepest" instead of adding
> > > global state for this?
> > 
> > I'm not sure what you mean?  A parameter of what in particular?  And where
> > to pass it?
> 
> Currently the code is:
> 
> static void freeze_enter(void)
> {
> + cpuidle_use_deepest_state(true);
>   cpuidle_resume();
>   wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
>   cpuidle_pause();
> + cpuidle_use_deepest_state(false);
> }
> 
> . I believe it would be better if you did
> 
> cpuidle_resume(GOTO_DEEPEST_C_STATE)
> 
> instead of having global state.

That's a good idea actually.  I'll do that on top of the $subject patch.

Thanks!

-- 
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Daniel Lezcano]

On 05/05/2014 12:51 AM, Rafael J. Wysocki wrote:
> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
>
> If freeze_enter() is called, we want to bypass the current cpuidle
> governor and always use the deepest available (that is, not disabled)
> C-state, because we want to save as much energy as reasonably possible
> then and runtime latency constraints don't matter at that point, since
> the system is in a sleep state anyway.
>
> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> ---
>
> This is on top of https://patchwork.kernel.org/patch/4071541/ .
>

Wouldn't make sense to revisit play_dead instead ?



-- 
  <http://www.linaro.org/> Linaro.org │ Open source software for ARM SoCs

Follow Linaro:  <http://www.facebook.com/pages/Linaro> Facebook |
<http://twitter.com/#!/linaroorg> Twitter |
<http://www.linaro.org/linaro-blog/> Blog

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Li, Aubrey]

On 2014/5/12 22:08, Daniel Lezcano wrote:
> On 05/05/2014 12:51 AM, Rafael J. Wysocki wrote:
>> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
>>
>> If freeze_enter() is called, we want to bypass the current cpuidle
>> governor and always use the deepest available (that is, not disabled)
>> C-state, because we want to save as much energy as reasonably possible
>> then and runtime latency constraints don't matter at that point, since
>> the system is in a sleep state anyway.
>>
>> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
>> ---
>>
>> This is on top of https://patchwork.kernel.org/patch/4071541/ .
>>
> 
> Wouldn't make sense to revisit play_dead instead ?
> 
play_dead() is broken.

Even if it works, we still should rely on cpuidle driver to place the
CPUs into the deepest c-state, because there is no architectural way to
enter deepest c-state and what play_dead() does is a bad assumption.

Thanks,
-Aubrey

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Daniel Lezcano]

On 05/12/2014 04:19 PM, Li, Aubrey wrote:
> On 2014/5/12 22:08, Daniel Lezcano wrote:
>> On 05/05/2014 12:51 AM, Rafael J. Wysocki wrote:
>>> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
>>>
>>> If freeze_enter() is called, we want to bypass the current cpuidle
>>> governor and always use the deepest available (that is, not disabled)
>>> C-state, because we want to save as much energy as reasonably possible
>>> then and runtime latency constraints don't matter at that point, since
>>> the system is in a sleep state anyway.
>>>
>>> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
>>> ---
>>>
>>> This is on top of https://patchwork.kernel.org/patch/4071541/ .
>>>
>>
>> Wouldn't make sense to revisit play_dead instead ?
>>
> play_dead() is broken.
>
> Even if it works, we still should rely on cpuidle driver to place the
> CPUs into the deepest c-state, because there is no architectural way to
> enter deepest c-state and what play_dead() does is a bad assumption.

Ok, let me rephrase it. Why not revisiting cpuidle_play_dead instead ?


-- 
  <http://www.linaro.org/> Linaro.org │ Open source software for ARM SoCs

Follow Linaro:  <http://www.facebook.com/pages/Linaro> Facebook |
<http://twitter.com/#!/linaroorg> Twitter |
<http://www.linaro.org/linaro-blog/> Blog

Re: [PATCH] PM / suspend: Always use deepest C-state in the "freeze" sleep state

[Rafael J. Wysocki]

On Monday, May 12, 2014 04:52:22 PM Daniel Lezcano wrote:
> On 05/12/2014 04:19 PM, Li, Aubrey wrote:
> > On 2014/5/12 22:08, Daniel Lezcano wrote:
> >> On 05/05/2014 12:51 AM, Rafael J. Wysocki wrote:
> >>> From: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> >>>
> >>> If freeze_enter() is called, we want to bypass the current cpuidle
> >>> governor and always use the deepest available (that is, not disabled)
> >>> C-state, because we want to save as much energy as reasonably possible
> >>> then and runtime latency constraints don't matter at that point, since
> >>> the system is in a sleep state anyway.
> >>>
> >>> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
> >>> ---
> >>>
> >>> This is on top of https://patchwork.kernel.org/patch/4071541/ .
> >>>
> >>
> >> Wouldn't make sense to revisit play_dead instead ?
> >>
> > play_dead() is broken.
> >
> > Even if it works, we still should rely on cpuidle driver to place the
> > CPUs into the deepest c-state, because there is no architectural way to
> > enter deepest c-state and what play_dead() does is a bad assumption.
> 
> Ok, let me rephrase it. Why not revisiting cpuidle_play_dead instead ?

Many drivers don't implement the ->enter_dead() callback.

-- 
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.