Workqueues can be performance or power oriented. For performance we may want to keep them running on a single cpu, so that it remains cache hot. For power we can give scheduler the liberty to choose target cpu for running work handler.

Later one (Power oriented WQ) can be achieved if the workqueue is allocated with WQ_UNBOUND flag. Enabling CONFIG_WQ_POWER_EFFICIENT will set 'wq_power_efficient' to 'true'. Setting 'power_efficient' boot param will override value of 'wq_power_efficient' variable. When 'wq_power_efficient' is set to 'true', we will convert WQ_POWER_EFFICIENT flag to WQ_UNBOUND on wq allocation. And so scheduler will have the liberty to choose where to run this work.

Signed-off-by: Viresh Kumar viresh.kumar@linaro.org --- Documentation/kernel-parameters.txt | 17 +++++++++++++++++ include/linux/workqueue.h | 3 +++ kernel/power/Kconfig | 19 +++++++++++++++++++ kernel/workqueue.c | 11 +++++++++++ 4 files changed, 50 insertions(+)

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt index c4fa000..a9040fa 100644 --- a/Documentation/kernel-parameters.txt +++ b/Documentation/kernel-parameters.txt @@ -3312,6 +3312,23 @@ bytes respectively. Such letter suffixes can also be entirely omitted. that this also can be controlled per-workqueue for workqueues visible under /sys/bus/workqueue/.

+ workqueue.power_efficient + Workqueues can be performance or power oriented. For + performance we may want to keep them running on a single + cpu, so that it remains cache hot. For power we can give + scheduler the liberty to choose target cpu for running + work handler. + + Later one (Power oriented WQ) can be achieved if the + workqueue is allocated with WQ_UNBOUND flag. Enabling + CONFIG_WQ_POWER_EFFICIENT will set 'wq_power_efficient' + to 'true'. Setting 'power_efficient' boot param will + override value of 'wq_power_efficient' variable. When + 'wq_power_efficient' is set to 'true', we will convert + WQ_POWER_EFFICIENT flag to WQ_UNBOUND on wq allocation. + And so scheduler will have the liberty to choose where + to run this work. + x2apic_phys [X86-64,APIC] Use x2apic physical mode instead of default x2apic cluster mode on platforms supporting x2apic. diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h index 623488f..83fa570 100644 --- a/include/linux/workqueue.h +++ b/include/linux/workqueue.h @@ -302,6 +302,9 @@ enum { WQ_HIGHPRI = 1 << 4, /* high priority */ WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */ + WQ_POWER_EFFICIENT = 1 << 7, /* WQ_UNBOUND, for power + * saving, if wq_power_efficient is + * enabled. Unused otherwise. */

__WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */ diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 5dfdc9e..e1e9c8b 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -263,6 +263,25 @@ config PM_GENERIC_DOMAINS bool depends on PM

+config WQ_POWER_EFFICIENT + bool "Workqueue allocated as UNBOUND (by default) for power efficiency" + depends on PM + help + Workqueues can be performance or power oriented. For performance we + may want to keep them running on a single cpu, so that it remains + cache hot. For power we can give scheduler the liberty to choose + target cpu for running work handler. + + Later one (Power oriented WQ) can be achieved if the workqueue is + allocated with WQ_UNBOUND flag. Enabling CONFIG_WQ_POWER_EFFICIENT + will set 'wq_power_efficient' to 'true'. Setting 'power_efficient' + boot param will override value of 'wq_power_efficient' variable. When + 'wq_power_efficient' is set to 'true', we will convert + WQ_POWER_EFFICIENT flag to WQ_UNBOUND on wq allocation. And so + scheduler will have the liberty to choose where to run this work. + + If in doubt, say N. + config PM_GENERIC_DOMAINS_SLEEP def_bool y depends on PM_SLEEP && PM_GENERIC_DOMAINS diff --git a/kernel/workqueue.c b/kernel/workqueue.c index 4aa9f5b..a327027 100644 --- a/kernel/workqueue.c +++ b/kernel/workqueue.c @@ -272,6 +272,14 @@ static cpumask_var_t *wq_numa_possible_cpumask; static bool wq_disable_numa; module_param_named(disable_numa, wq_disable_numa, bool, 0444);

+#ifdef CONFIG_WQ_POWER_EFFICIENT +static bool wq_power_efficient = true; +#else +static bool wq_power_efficient; +#endif + +module_param_named(power_efficient, wq_power_efficient, bool, 0444); + static bool wq_numa_enabled; /* unbound NUMA affinity enabled */

/* buf for wq_update_unbound_numa_attrs(), protected by CPU hotplug exclusion */ @@ -4085,6 +4093,9 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt, struct workqueue_struct *wq; struct pool_workqueue *pwq;

+ if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient) + flags |= WQ_UNBOUND; + /* allocate wq and format name */ if (flags & WQ_UNBOUND) tbl_size = wq_numa_tbl_len * sizeof(wq->numa_pwq_tbl[0]);

Phylib uses workqueues for multiple purposes. There is no real dependency of scheduling these on the cpu which scheduled them.

On a idle system, it is observed that and idle cpu wakes up many times just to service this work. It would be better if we can schedule it on a cpu which the scheduler believes to be the most appropriate one.

This patch replaces system_wq with system_power_efficient_wq for PHYLIB.

Cc: David S. Miller davem@davemloft.net Cc: netdev@vger.kernel.org Signed-off-by: Viresh Kumar viresh.kumar@linaro.org Acked-by: David S. Miller davem@davemloft.net --- drivers/net/phy/phy.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c index c14f147..984c0b5 100644 --- a/drivers/net/phy/phy.c +++ b/drivers/net/phy/phy.c @@ -439,7 +439,7 @@ void phy_start_machine(struct phy_device *phydev, { phydev->adjust_state = handler;

- schedule_delayed_work(&phydev->state_queue, HZ); + queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ); }

/** @@ -500,7 +500,7 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) disable_irq_nosync(irq); atomic_inc(&phydev->irq_disable);

- schedule_work(&phydev->phy_queue); + queue_work(system_power_efficient_wq, &phydev->phy_queue);

return IRQ_HANDLED; } @@ -655,7 +655,7 @@ static void phy_change(struct work_struct *work)

/* reschedule state queue work to run as soon as possible */ cancel_delayed_work_sync(&phydev->state_queue); - schedule_delayed_work(&phydev->state_queue, 0); + queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0);

return;

@@ -918,7 +918,8 @@ void phy_state_machine(struct work_struct *work) if (err < 0) phy_error(phydev);

- schedule_delayed_work(&phydev->state_queue, PHY_STATE_TIME * HZ); + queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, + PHY_STATE_TIME * HZ); }

static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad,

fbcon uses workqueues and it has no real dependency of scheduling these on the cpu which scheduled them.

On a idle system, it is observed that and idle cpu wakes up many times just to service this work. It would be better if we can schedule it on a cpu which the scheduler believes to be the most appropriate one.

This patch replaces system_wq with system_power_efficient_wq.

Cc: Dave Airlie airlied@redhat.com Cc: linux-fbdev@vger.kernel.org Signed-off-by: Viresh Kumar viresh.kumar@linaro.org --- drivers/video/console/fbcon.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c index 3cd6759..0cae83d 100644 --- a/drivers/video/console/fbcon.c +++ b/drivers/video/console/fbcon.c @@ -404,7 +404,7 @@ static void cursor_timer_handler(unsigned long dev_addr) struct fb_info *info = (struct fb_info *) dev_addr; struct fbcon_ops *ops = info->fbcon_par;

- schedule_work(&info->queue); + queue_work(system_power_efficient_wq, &info->queue); mod_timer(&ops->cursor_timer, jiffies + HZ/5); }

On Thu, Apr 25, 2013 at 9:13 AM, Viresh Kumar viresh.kumar@linaro.org wrote:

On 25 April 2013 09:00, Amit Kucheria amit.kucheria@linaro.org wrote:

...

Yes. That was my intention - preventing a prompt on existing defconfigs and there by maintaining current behavior.

Hmm... Following is the version after fixing all problems you reported. @Tejun: I have attached it too as gmail's copy-paste may break it. Please consider applying this series if it looks fine to you.

---------------x----------------x---------------------

From: Viresh Kumar viresh.kumar@linaro.org Date: Mon, 8 Apr 2013 16:45:40 +0530 Subject: [PATCH V5 1/5] workqueues: Introduce new flag WQ_POWER_EFFICIENT for power oriented workqueues

Workqueues can be performance or power-oriented. Currently, most workqueues are bound to the CPU they were created on. This gives good performance (due to cache effects) at the cost of potentially waking up otherwise idle cores just to process some work. To save power, we can allow the work to be rescheduled on a core that is already awake.

Workqueues created with the WQ_UNBOUND flag will allow some power savings. However, we don't change the default behaviour of the system. To enable power-saving behaviour, a new config option CONFIG_WQ_POWER_EFFICIENT needs to be turned on. This option can also be overridden by the workqueue.power_efficient boot parameter.

Signed-off-by: Viresh Kumar viresh.kumar@linaro.org

For the series, you can add my:

Reviewed-by: Amit Kucheria amit.kucheria@linaro.org

---

Documentation/kernel-parameters.txt | 17 +++++++++++++++++ include/linux/workqueue.h | 3 +++ kernel/power/Kconfig | 19 +++++++++++++++++++ kernel/workqueue.c | 11 +++++++++++ 4 files changed, 50 insertions(+)

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt index c4fa000..22edc83 100644 --- a/Documentation/kernel-parameters.txt +++ b/Documentation/kernel-parameters.txt @@ -3312,6 +3312,23 @@ bytes respectively. Such letter suffixes can also be entirely omitted. that this also can be controlled per-workqueue for workqueues visible under /sys/bus/workqueue/.

•   workqueue.power_efficient
  

•                   Workqueues can be performance or power-oriented.
  

•                   Currently, most workqueues are bound to the CPU they
  

•                   were created on. This gives good performance (due to
  

•                   cache effects) at the cost of potentially waking up
  

•                   otherwise idle cores just to process some work. To save
  

•                   power, we can allow the work to be rescheduled on a core
  

•                   that is already awake.
  

•                   Workqueues created with the WQ_UNBOUND flag will allow
  

•                   some power savings.  However, we don't change the
  

•                   default behaviour of the system.  To enable power-saving
  

•                   behaviour, a new config option CONFIG_WQ_POWER_EFFICIENT
  

•                   needs to be turned on. This option can also be
  

•                   overridden by the workqueue.power_efficient boot
  

•                   parameter.
  

•   x2apic_phys     [X86-64,APIC] Use x2apic physical mode instead of
                    default x2apic cluster mode on platforms
                    supporting x2apic.
  

diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h index 623488f..83fa570 100644 --- a/include/linux/workqueue.h +++ b/include/linux/workqueue.h @@ -302,6 +302,9 @@ enum { WQ_HIGHPRI = 1 << 4, /* high priority */ WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */

•   WQ_POWER_EFFICIENT      = 1 << 7, /* WQ_UNBOUND, for power
  

•                                      * saving, if wq_power_efficient is
  

•                                      * enabled. Unused otherwise. */
  
    __WQ_DRAINING           = 1 << 16, /* internal: workqueue is draining */
    __WQ_ORDERED            = 1 << 17, /* internal: workqueue is ordered */
  

diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 5dfdc9e..018f039 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -263,6 +263,25 @@ config PM_GENERIC_DOMAINS bool depends on PM

+config WQ_POWER_EFFICIENT

•   bool "Workqueue allocated as UNBOUND (by default) for power efficiency"
  

•   depends on PM
  

•   default n
  

•   help
  

•     Workqueues can be performance or power-oriented. Currently, most
  

•     workqueues are bound to the CPU they were created on. This gives good
  

•     performance (due to cache effects) at the cost of potentially waking
  

•     up otherwise idle cores just to process some work. To save power, we
  

•     can allow the work to be rescheduled on a core that is already awake.
  

•     Workqueues created with the WQ_UNBOUND flag will allow some power
  

•     savings.  However, we don't change the default behaviour of the
  

•     system.  To enable power-saving behaviour, a new config option
  

•     CONFIG_WQ_POWER_EFFICIENT needs to be turned on. This option can also
  

•     be overridden by the workqueue.power_efficient boot parameter.
  

•     If in doubt, say N.
  

config PM_GENERIC_DOMAINS_SLEEP def_bool y depends on PM_SLEEP && PM_GENERIC_DOMAINS diff --git a/kernel/workqueue.c b/kernel/workqueue.c index 4aa9f5b..a327027 100644 --- a/kernel/workqueue.c +++ b/kernel/workqueue.c @@ -272,6 +272,14 @@ static cpumask_var_t *wq_numa_possible_cpumask; static bool wq_disable_numa; module_param_named(disable_numa, wq_disable_numa, bool, 0444);

+#ifdef CONFIG_WQ_POWER_EFFICIENT +static bool wq_power_efficient = true; +#else +static bool wq_power_efficient; +#endif

+module_param_named(power_efficient, wq_power_efficient, bool, 0444);

static bool wq_numa_enabled; /* unbound NUMA affinity enabled */

/* buf for wq_update_unbound_numa_attrs(), protected by CPU hotplug exclusion */ @@ -4085,6 +4093,9 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt, struct workqueue_struct *wq; struct pool_workqueue *pwq;

•   if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient)
  

•           flags |= WQ_UNBOUND;
  

•   /* allocate wq and format name */
    if (flags & WQ_UNBOUND)
            tbl_size = wq_numa_tbl_len * sizeof(wq->numa_pwq_tbl[0]);
  

On 27 April 2013 00:41, Tejun Heo tj@kernel.org wrote:

It's already too late for the upcoming merge window, but things generally look good to me and I'll apply the patchset once wq/for-3.11 opens. One nitpick tho.

On Thu, Apr 25, 2013 at 09:13:44AM +0530, Viresh Kumar wrote:

...

• workqueue.power_efficient
  

•                 Workqueues can be performance or power-oriented.
  

•                 Currently, most workqueues are bound to the CPU they
  

                               ^^^^
                               per-cpu would be better

...

•                 were created on. This gives good performance (due to
  

•                 cache effects) at the cost of potentially waking up
  

•                 otherwise idle cores just to process some work. To save
  

•                 power, we can allow the work to be rescheduled on a core
  

•                 that is already awake.
  

The above description is confusing to me. As have been discussed multiple times before, per-cpu workqueue in itself doesn't wake up the CPU physically. The timer may but per-cpu workqueue doesn't. It was confusing when this patchset was first posted and the above phrasing is still confusing. What the patchset tries to do is preventing the scheduler from perceiving the CPU as active due to the activated worker thread pinned to that CPU, right? The knob doesn't really do anything about waking up the processor in itself. It just avoids feeding the scheduler with noisy activation events and allows it to allocate work item execution according to the scheduler's view of CPU active/idleness. As the scheduler has longer / larger scope of overall CPU activities and means to regulate them, this leads to more power-efficient allocation of work item executions, right? It'd be really great if the descriptions and the comment above the flag makes this abundantly clear because it's not something too apparent.

Sorry for the long delay for such a small change. I went on long leaves..

I have added following to make things more clear at places: (Idle from scheduler's perspective. Which may or may not be physically idle)..

Let me know if it is still unclear..

And this is the new patch: (Attached it too for applying cleanly)

---------x---------------x-------------------

From: Viresh Kumar viresh.kumar@linaro.org Date: Mon, 8 Apr 2013 16:45:40 +0530 Subject: [PATCH V5 resent 1/5] workqueues: Introduce new flag WQ_POWER_EFFICIENT for power oriented workqueues

Workqueues can be performance or power-oriented. Currently, most workqueues are bound to the CPU they were created on. This gives good performance (due to cache effects) at the cost of potentially waking up otherwise idle cores (Idle from scheduler's perspective. Which may or may not be physically idle) just to process some work. To save power, we can allow the work to be rescheduled on a core that is already awake.

Workqueues created with the WQ_UNBOUND flag will allow some power savings. However, we don't change the default behaviour of the system. To enable power-saving behaviour, a new config option CONFIG_WQ_POWER_EFFICIENT needs to be turned on. This option can also be overridden by the workqueue.power_efficient boot parameter.

Signed-off-by: Viresh Kumar viresh.kumar@linaro.org Reviewed-by: Amit Kucheria amit.kucheria@linaro.org --- Documentation/kernel-parameters.txt | 18 ++++++++++++++++++ include/linux/workqueue.h | 3 +++ kernel/power/Kconfig | 21 +++++++++++++++++++++ kernel/workqueue.c | 11 +++++++++++ 4 files changed, 53 insertions(+)

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt index c3bfacb..9a991b6 100644 --- a/Documentation/kernel-parameters.txt +++ b/Documentation/kernel-parameters.txt @@ -3320,6 +3320,24 @@ bytes respectively. Such letter suffixes can also be entirely omitted. that this also can be controlled per-workqueue for workqueues visible under /sys/bus/workqueue/.

+ workqueue.power_efficient + Workqueues can be performance or power-oriented. + Currently, most workqueues are bound to the CPU they + were created on. This gives good performance (due to + cache effects) at the cost of potentially waking up + otherwise idle cores (Idle from scheduler's perspective. + Which may or may not be physically idle) just to process + some work. To save power, we can allow the work to be + rescheduled on a core that is already awake. + + Workqueues created with the WQ_UNBOUND flag will allow + some power savings. However, we don't change the + default behaviour of the system. To enable power-saving + behaviour, a new config option CONFIG_WQ_POWER_EFFICIENT + needs to be turned on. This option can also be + overridden by the workqueue.power_efficient boot + parameter. + x2apic_phys [X86-64,APIC] Use x2apic physical mode instead of default x2apic cluster mode on platforms supporting x2apic. diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h index 623488f..83fa570 100644 --- a/include/linux/workqueue.h +++ b/include/linux/workqueue.h @@ -302,6 +302,9 @@ enum { WQ_HIGHPRI = 1 << 4, /* high priority */ WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */ + WQ_POWER_EFFICIENT = 1 << 7, /* WQ_UNBOUND, for power + * saving, if wq_power_efficient is + * enabled. Unused otherwise. */

__WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */ diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 5dfdc9e..e8c2b77 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -263,6 +263,27 @@ config PM_GENERIC_DOMAINS bool depends on PM

+config WQ_POWER_EFFICIENT + bool "Workqueue allocated as UNBOUND (by default) for power efficiency" + depends on PM + default n + help + Workqueues can be performance or power-oriented. Currently, most + workqueues are bound to the CPU they were created on. This gives good + performance (due to cache effects) at the cost of potentially waking + up otherwise idle cores (Idle from scheduler's perspective. Which may + or may not be physically idle) just to process some work. To save + power, we can allow the work to be rescheduled on a core that is + already awake. + + Workqueues created with the WQ_UNBOUND flag will allow some power + savings. However, we don't change the default behaviour of the + system. To enable power-saving behaviour, a new config option + CONFIG_WQ_POWER_EFFICIENT needs to be turned on. This option can also + be overridden by the workqueue.power_efficient boot parameter. + + If in doubt, say N. + config PM_GENERIC_DOMAINS_SLEEP def_bool y depends on PM_SLEEP && PM_GENERIC_DOMAINS diff --git a/kernel/workqueue.c b/kernel/workqueue.c index 1ae6028..9d8753e 100644 --- a/kernel/workqueue.c +++ b/kernel/workqueue.c @@ -272,6 +272,14 @@ static cpumask_var_t *wq_numa_possible_cpumask; static bool wq_disable_numa; module_param_named(disable_numa, wq_disable_numa, bool, 0444);

+#ifdef CONFIG_WQ_POWER_EFFICIENT +static bool wq_power_efficient = true; +#else +static bool wq_power_efficient; +#endif + +module_param_named(power_efficient, wq_power_efficient, bool, 0444); + static bool wq_numa_enabled; /* unbound NUMA affinity enabled */

/* buf for wq_update_unbound_numa_attrs(), protected by CPU hotplug exclusion */ @@ -4085,6 +4093,9 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt, struct workqueue_struct *wq; struct pool_workqueue *pwq;

+ if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient) + flags |= WQ_UNBOUND; + /* allocate wq and format name */ if (flags & WQ_UNBOUND) tbl_size = wq_numa_tbl_len * sizeof(wq->numa_pwq_tbl[0]);

From cee22a15052faa817e3ec8985a28154d3fabc7aa Mon Sep 17 00:00:00 2001

From: Viresh Kumar viresh.kumar@linaro.org Date: Mon, 8 Apr 2013 16:45:40 +0530 Subject: workqueues: Introduce new flag WQ_POWER_EFFICIENT for power oriented workqueues

Workqueues can be performance or power-oriented. Currently, most workqueues are bound to the CPU they were created on. This gives good performance (due to cache effects) at the cost of potentially waking up otherwise idle cores (Idle from scheduler's perspective. Which may or may not be physically idle) just to process some work. To save power, we can allow the work to be rescheduled on a core that is already awake.

Workqueues created with the WQ_UNBOUND flag will allow some power savings. However, we don't change the default behaviour of the system. To enable power-saving behaviour, a new config option CONFIG_WQ_POWER_EFFICIENT needs to be turned on. This option can also be overridden by the workqueue.power_efficient boot parameter.

tj: Updated config description and comments. Renamed CONFIG_WQ_POWER_EFFICIENT to CONFIG_WQ_POWER_EFFICIENT_DEFAULT.

Signed-off-by: Viresh Kumar viresh.kumar@linaro.org Reviewed-by: Amit Kucheria amit.kucheria@linaro.org Signed-off-by: Tejun Heo tj@kernel.org --- Documentation/kernel-parameters.txt | 15 +++++++++++++++ include/linux/workqueue.h | 27 +++++++++++++++++++++++++++ kernel/power/Kconfig | 20 ++++++++++++++++++++ kernel/workqueue.c | 13 +++++++++++++ 4 files changed, 75 insertions(+)

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt index c3bfacb..37dfd72 100644 --- a/Documentation/kernel-parameters.txt +++ b/Documentation/kernel-parameters.txt @@ -3320,6 +3320,21 @@ bytes respectively. Such letter suffixes can also be entirely omitted. that this also can be controlled per-workqueue for workqueues visible under /sys/bus/workqueue/.

+ workqueue.power_efficient + Per-cpu workqueues are generally preferred because + they show better performance thanks to cache + locality; unfortunately, per-cpu workqueues tend to + be more power hungry than unbound workqueues. + + Enabling this makes the per-cpu workqueues which + were observed to contribute significantly to power + consumption unbound, leading to measurably lower + power usage at the cost of small performance + overhead. + + The default value of this parameter is determined by + the config option CONFIG_WQ_POWER_EFFICIENT_DEFAULT. + x2apic_phys [X86-64,APIC] Use x2apic physical mode instead of default x2apic cluster mode on platforms supporting x2apic. diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h index 623488f..fc0136b 100644 --- a/include/linux/workqueue.h +++ b/include/linux/workqueue.h @@ -303,6 +303,33 @@ enum { WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */

+ /* + * Per-cpu workqueues are generally preferred because they tend to + * show better performance thanks to cache locality. Per-cpu + * workqueues exclude the scheduler from choosing the CPU to + * execute the worker threads, which has an unfortunate side effect + * of increasing power consumption. + * + * The scheduler considers a CPU idle if it doesn't have any task + * to execute and tries to keep idle cores idle to conserve power; + * however, for example, a per-cpu work item scheduled from an + * interrupt handler on an idle CPU will force the scheduler to + * excute the work item on that CPU breaking the idleness, which in + * turn may lead to more scheduling choices which are sub-optimal + * in terms of power consumption. + * + * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default + * but become unbound if workqueue.power_efficient kernel param is + * specified. Per-cpu workqueues which are identified to + * contribute significantly to power-consumption are identified and + * marked with this flag and enabling the power_efficient mode + * leads to noticeable power saving at the cost of small + * performance disadvantage. + * + * http://thread.gmane.org/gmane.linux.kernel/1480396 + */ + WQ_POWER_EFFICIENT = 1 << 7, + __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */

diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig index 5dfdc9e..4645596 100644 --- a/kernel/power/Kconfig +++ b/kernel/power/Kconfig @@ -263,6 +263,26 @@ config PM_GENERIC_DOMAINS bool depends on PM

+config WQ_POWER_EFFICIENT_DEFAULT + bool "Enable workqueue power-efficient mode by default" + depends on PM + default n + help + Per-cpu workqueues are generally preferred because they show + better performance thanks to cache locality; unfortunately, + per-cpu workqueues tend to be more power hungry than unbound + workqueues. + + Enabling workqueue.power_efficient kernel parameter makes the + per-cpu workqueues which were observed to contribute + significantly to power consumption unbound, leading to measurably + lower power usage at the cost of small performance overhead. + + This config option determines whether workqueue.power_efficient + is enabled by default. + + If in doubt, say N. + config PM_GENERIC_DOMAINS_SLEEP def_bool y depends on PM_SLEEP && PM_GENERIC_DOMAINS diff --git a/kernel/workqueue.c b/kernel/workqueue.c index 4aa9f5b..8068d97 100644 --- a/kernel/workqueue.c +++ b/kernel/workqueue.c @@ -272,6 +272,15 @@ static cpumask_var_t *wq_numa_possible_cpumask; static bool wq_disable_numa; module_param_named(disable_numa, wq_disable_numa, bool, 0444);

+/* see the comment above the definition of WQ_POWER_EFFICIENT */ +#ifdef CONFIG_WQ_POWER_EFFICIENT_DEFAULT +static bool wq_power_efficient = true; +#else +static bool wq_power_efficient; +#endif + +module_param_named(power_efficient, wq_power_efficient, bool, 0444); + static bool wq_numa_enabled; /* unbound NUMA affinity enabled */

/* buf for wq_update_unbound_numa_attrs(), protected by CPU hotplug exclusion */ @@ -4085,6 +4094,10 @@ struct workqueue_struct *__alloc_workqueue_key(const char *fmt, struct workqueue_struct *wq; struct pool_workqueue *pwq;

+ /* see the comment above the definition of WQ_POWER_EFFICIENT */ + if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient) + flags |= WQ_UNBOUND; + /* allocate wq and format name */ if (flags & WQ_UNBOUND) tbl_size = wq_numa_tbl_len * sizeof(wq->numa_pwq_tbl[0]);