As a first step towards improving the power awareness of the scheduler, this patch enables a "dumb" state where all power management is turned off. Whatever additionally we put into the kernel for cpu power management must do better than this in terms of performance as well as powersavings. This will enable us to benchmark and optimize the power aware scheduler from scratch.If we are to benchmark it against the performance of the existing design, we will get sufficiently distracted by the performance numbers and get steered away from a sane design.

Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

arch/powerpc/Kconfig | 1 + arch/powerpc/platforms/powernv/Kconfig | 12 ++++++------ drivers/cpufreq/Kconfig | 2 ++ drivers/cpuidle/Kconfig | 2 ++ kernel/Kconfig.sched | 11 +++++++++++ 5 files changed, 22 insertions(+), 6 deletions(-) create mode 100644 kernel/Kconfig.sched

diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig index 80b94b0..b7fe36a 100644 --- a/arch/powerpc/Kconfig +++ b/arch/powerpc/Kconfig @@ -301,6 +301,7 @@ config HIGHMEM

source kernel/Kconfig.hz source kernel/Kconfig.preempt +source kernel/Kconfig.sched source "fs/Kconfig.binfmt"

config HUGETLB_PAGE_SIZE_VARIABLE diff --git a/arch/powerpc/platforms/powernv/Kconfig b/arch/powerpc/platforms/powernv/Kconfig index 45a8ed0..b0ef8b1 100644 --- a/arch/powerpc/platforms/powernv/Kconfig +++ b/arch/powerpc/platforms/powernv/Kconfig @@ -11,12 +11,12 @@ config PPC_POWERNV select PPC_UDBG_16550 select PPC_SCOM select ARCH_RANDOM - select CPU_FREQ - select CPU_FREQ_GOV_PERFORMANCE - select CPU_FREQ_GOV_POWERSAVE - select CPU_FREQ_GOV_USERSPACE - select CPU_FREQ_GOV_ONDEMAND - select CPU_FREQ_GOV_CONSERVATIVE + select CPU_FREQ if !SCHED_POWER + select CPU_FREQ_GOV_PERFORMANCE if CPU_FREQ + select CPU_FREQ_GOV_POWERSAVE if CPU_FREQ + select CPU_FREQ_GOV_USERSPACE if CPU_FREQ + select CPU_FREQ_GOV_ONDEMAND if CPU_FREQ + select CPU_FREQ_GOV_CONSERVATIVE if CPU_FREQ select PPC_DOORBELL default y

diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig index ffe350f..8976fd6 100644 --- a/drivers/cpufreq/Kconfig +++ b/drivers/cpufreq/Kconfig @@ -2,6 +2,7 @@ menu "CPU Frequency scaling"

config CPU_FREQ bool "CPU Frequency scaling" + depends on !SCHED_POWER help CPU Frequency scaling allows you to change the clock speed of CPUs on the fly. This is a nice method to save power, because @@ -12,6 +13,7 @@ config CPU_FREQ (see below) after boot, or use a userspace tool.

For details, take a look at file:Documentation/cpu-freq. + This feature will turn off if power aware scheduling is enabled.

If in doubt, say N.

diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig index 32748c3..2c4ac79 100644 --- a/drivers/cpuidle/Kconfig +++ b/drivers/cpuidle/Kconfig @@ -3,6 +3,7 @@ menu "CPU Idle" config CPU_IDLE bool "CPU idle PM support" default y if ACPI || PPC_PSERIES + depends on !SCHED_POWER select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE) select CPU_IDLE_GOV_MENU if (NO_HZ || NO_HZ_IDLE) help @@ -11,6 +12,7 @@ config CPU_IDLE governors that can be swapped during runtime.

If you're using an ACPI-enabled platform, you should say Y here. + This feature will turn off if power aware scheduling is enabled.

if CPU_IDLE

diff --git a/kernel/Kconfig.sched b/kernel/Kconfig.sched new file mode 100644 index 0000000..374454c --- /dev/null +++ b/kernel/Kconfig.sched @@ -0,0 +1,11 @@ +menu "Power Aware Scheduling" + +config SCHED_POWER + bool "Power Aware Scheduler" + default n + help + Select this to enable the new power aware scheduler. +endmenu + + +

The goal of the power aware scheduling design is to integrate all policy, metrics and averaging into the scheduler. Today the cpu power management is fragmented and hence inconsistent.

As a first step towards this integration, rid the cpuidle state management of the governors. Retain only the cpuidle driver in the cpu idle susbsystem which acts as an interface between the scheduler and low level platform specific cpuidle drivers. For all decision making around selection of idle states,the cpuidle driver falls back to the scheduler.

The current algorithm for idle state selection is the same as the logic used by the menu governor. However going ahead the heuristics will be tuned and improved upon with metrics better known to the scheduler.

Note: cpufrequency is still left disabled when CONFIG_SCHED_POWER is selected.

Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

drivers/cpuidle/Kconfig | 12 + drivers/cpuidle/cpuidle-powernv.c | 2 drivers/cpuidle/cpuidle.c | 65 ++++- include/linux/sched.h | 9 + kernel/sched/Makefile | 1 kernel/sched/power.c | 480 +++++++++++++++++++++++++++++++++++++ 6 files changed, 554 insertions(+), 15 deletions(-) create mode 100644 kernel/sched/power.c

diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig index 2c4ac79..4fa4cb1 100644 --- a/drivers/cpuidle/Kconfig +++ b/drivers/cpuidle/Kconfig @@ -3,16 +3,14 @@ menu "CPU Idle" config CPU_IDLE bool "CPU idle PM support" default y if ACPI || PPC_PSERIES - depends on !SCHED_POWER - select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE) - select CPU_IDLE_GOV_MENU if (NO_HZ || NO_HZ_IDLE) + select CPU_IDLE_GOV_LADDER if (!NO_HZ && !NO_HZ_IDLE && !SCHED_POWER) + select CPU_IDLE_GOV_MENU if ((NO_HZ || NO_HZ_IDLE) && !SCHED_POWER) help CPU idle is a generic framework for supporting software-controlled idle processor power management. It includes modular cross-platform governors that can be swapped during runtime.

If you're using an ACPI-enabled platform, you should say Y here. - This feature will turn off if power aware scheduling is enabled.

if CPU_IDLE

@@ -22,10 +20,16 @@ config CPU_IDLE_MULTIPLE_DRIVERS config CPU_IDLE_GOV_LADDER bool "Ladder governor (for periodic timer tick)" default y + depends on !SCHED_POWER + help + This feature will turn off if power aware scheduling is enabled.

config CPU_IDLE_GOV_MENU bool "Menu governor (for tickless system)" default y + depends on !SCHED_POWER + help + This feature will turn off if power aware scheduling is enabled.

menu "ARM CPU Idle Drivers" depends on ARM diff --git a/drivers/cpuidle/cpuidle-powernv.c b/drivers/cpuidle/cpuidle-powernv.c index fa79392..95ef533 100644 --- a/drivers/cpuidle/cpuidle-powernv.c +++ b/drivers/cpuidle/cpuidle-powernv.c @@ -70,7 +70,7 @@ static int fastsleep_loop(struct cpuidle_device *dev, unsigned long new_lpcr;

if (powersave_nap < 2) - return; + return 0; if (unlikely(system_state < SYSTEM_RUNNING)) return index;

diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c index ee9df5e..38fb213 100644 --- a/drivers/cpuidle/cpuidle.c +++ b/drivers/cpuidle/cpuidle.c @@ -150,6 +150,19 @@ int cpuidle_enter_state(struct cpuidle_device *dev, struct cpuidle_driver *drv, return entered_state; }

+#ifdef CONFIG_SCHED_POWER +static int __cpuidle_select(struct cpuidle_driver *drv, + struct cpuidle_device *dev) +{ + return cpuidle_sched_select(drv, dev); +} +#else +static int __cpuidle_select(struct cpuidle_driver *drv, + struct cpuidle_device *dev) +{ + return cpuidle_curr_governor->select(drv, dev); +} +#endif /** * cpuidle_select - ask the cpuidle framework to choose an idle state * @@ -169,7 +182,7 @@ int cpuidle_select(struct cpuidle_driver *drv, struct cpuidle_device *dev) if (unlikely(use_deepest_state)) return cpuidle_find_deepest_state(drv, dev);

- return cpuidle_curr_governor->select(drv, dev); + return __cpuidle_select(drv, dev); }

/** @@ -190,6 +203,18 @@ int cpuidle_enter(struct cpuidle_driver *drv, struct cpuidle_device *dev, return cpuidle_enter_state(dev, drv, index); }

+#ifdef CONFIG_SCHED_POWER +static void __cpuidle_reflect(struct cpuidle_device *dev, int index) +{ + cpuidle_sched_reflect(dev, index); +} +#else +static void __cpuidle_reflect(struct cpuidle_device *dev, int index) +{ + if (cpuidle_curr_governor->reflect && !unlikely(use_deepest_state)) + cpuidle_curr_governor->reflect(dev, index); +} +#endif /** * cpuidle_reflect - tell the underlying governor what was the state * we were in @@ -200,8 +225,7 @@ int cpuidle_enter(struct cpuidle_driver *drv, struct cpuidle_device *dev, */ void cpuidle_reflect(struct cpuidle_device *dev, int index) { - if (cpuidle_curr_governor->reflect && !unlikely(use_deepest_state)) - cpuidle_curr_governor->reflect(dev, index); + __cpuidle_reflect(dev, index); }

/** @@ -265,6 +289,28 @@ void cpuidle_resume(void) mutex_unlock(&cpuidle_lock); }

+#ifdef CONFIG_SCHED_POWER +static int cpuidle_check_governor(struct cpuidle_driver *drv, + struct cpuidle_device *dev, int enable) +{ + if (enable) + return cpuidle_sched_enable_device(drv, dev); + else + return 0; +} +#else +static int cpuidle_check_governor(struct cpuidle_driver *drv, + struct cpuidle_device *dev, int enable) +{ + if (!cpuidle_curr_governor) + return -EIO; + + if (enable && cpuidle_curr_governor->enable) + return cpuidle_curr_governor->enable(drv, dev); + else if (cpuidle_curr_governor->disable) + cpuidle_curr_governor->disable(drv, dev); +} +#endif /** * cpuidle_enable_device - enables idle PM for a CPU * @dev: the CPU @@ -285,7 +331,7 @@ int cpuidle_enable_device(struct cpuidle_device *dev)

drv = cpuidle_get_cpu_driver(dev);

- if (!drv || !cpuidle_curr_governor) + if (!drv) return -EIO;

if (!dev->registered) @@ -298,8 +344,8 @@ int cpuidle_enable_device(struct cpuidle_device *dev) if (ret) return ret;

- if (cpuidle_curr_governor->enable && - (ret = cpuidle_curr_governor->enable(drv, dev))) + ret = cpuidle_check_governor(drv, dev, 1); + if (ret) goto fail_sysfs;

smp_wmb(); @@ -331,13 +377,12 @@ void cpuidle_disable_device(struct cpuidle_device *dev) if (!dev || !dev->enabled) return;

- if (!drv || !cpuidle_curr_governor) + if (!drv) return; - + dev->enabled = 0;

- if (cpuidle_curr_governor->disable) - cpuidle_curr_governor->disable(drv, dev); + cpuidle_check_governor(drv, dev, 0);

cpuidle_remove_device_sysfs(dev); enabled_devices--; diff --git a/include/linux/sched.h b/include/linux/sched.h index 7c19d55..5dd99b5 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -26,6 +26,7 @@ struct sched_param { #include <linux/nodemask.h> #include <linux/mm_types.h> #include <linux/preempt_mask.h> +#include <linux/cpuidle.h>

#include <asm/page.h> #include <asm/ptrace.h> @@ -846,6 +847,14 @@ enum cpu_idle_type { CPU_MAX_IDLE_TYPES };

+#ifdef CONFIG_SCHED_POWER +extern void cpuidle_sched_reflect(struct cpuidle_device *dev, int index); +extern int cpuidle_sched_select(struct cpuidle_driver *drv, + struct cpuidle_device *dev); +extern int cpuidle_sched_enable_device(struct cpuidle_driver *drv, + struct cpuidle_device *dev); +#endif + /* * Increase resolution of cpu_capacity calculations */ diff --git a/kernel/sched/Makefile b/kernel/sched/Makefile index ab32b7b..5b8e469 100644 --- a/kernel/sched/Makefile +++ b/kernel/sched/Makefile @@ -19,3 +19,4 @@ obj-$(CONFIG_SCHED_AUTOGROUP) += auto_group.o obj-$(CONFIG_SCHEDSTATS) += stats.o obj-$(CONFIG_SCHED_DEBUG) += debug.o obj-$(CONFIG_CGROUP_CPUACCT) += cpuacct.o +obj-$(CONFIG_SCHED_POWER) += power.o diff --git a/kernel/sched/power.c b/kernel/sched/power.c new file mode 100644 index 0000000..63c9276 --- /dev/null +++ b/kernel/sched/power.c @@ -0,0 +1,480 @@ +/* + * power.c - the power aware scheduler + * + * Author: + * Preeti U. Murthy preeti@linux.vnet.ibm.com + * + * This code is a replica of drivers/cpuidle/governors/menu.c + * To make the transition to power aware scheduler away from + * the cpuidle governor model easy, we do exactly what the + * governors do for now. Going ahead the heuristics will be + * tuned and improved upon. + * + * This code is licenced under the GPL version 2 as described + * in the COPYING file that acompanies the Linux Kernel. + */ + +#include <linux/kernel.h> +#include <linux/cpuidle.h> +#include <linux/pm_qos.h> +#include <linux/time.h> +#include <linux/ktime.h> +#include <linux/hrtimer.h> +#include <linux/tick.h> +#include <linux/sched.h> +#include <linux/math64.h> +#include <linux/module.h> + +/* + * Please note when changing the tuning values: + * If (MAX_INTERESTING-1) * RESOLUTION > UINT_MAX, the result of + * a scaling operation multiplication may overflow on 32 bit platforms. + * In that case, #define RESOLUTION as ULL to get 64 bit result: + * #define RESOLUTION 1024ULL + * + * The default values do not overflow. + */ +#define BUCKETS 12 +#define INTERVALS 8 +#define RESOLUTION 1024 +#define DECAY 8 +#define MAX_INTERESTING 50000 + + +/* + * Concepts and ideas behind the power aware scheduler + * + * For the power aware scheduler, there are 3 decision factors for picking a C + * state: + * 1) Energy break even point + * 2) Performance impact + * 3) Latency tolerance (from pmqos infrastructure) + * These these three factors are treated independently. + * + * Energy break even point + * ----------------------- + * C state entry and exit have an energy cost, and a certain amount of time in + * the C state is required to actually break even on this cost. CPUIDLE + * provides us this duration in the "target_residency" field. So all that we + * need is a good prediction of how long we'll be idle. Like the traditional + * governors, we start with the actual known "next timer event" time. + * + * Since there are other source of wakeups (interrupts for example) than + * the next timer event, this estimation is rather optimistic. To get a + * more realistic estimate, a correction factor is applied to the estimate, + * that is based on historic behavior. For example, if in the past the actual + * duration always was 50% of the next timer tick, the correction factor will + * be 0.5. + * + * power aware scheduler uses a running average for this correction factor, + * however it uses a set of factors, not just a single factor. This stems from + * the realization that the ratio is dependent on the order of magnitude of the + * expected duration; if we expect 500 milliseconds of idle time the likelihood of + * getting an interrupt very early is much higher than if we expect 50 micro + * seconds of idle time. A second independent factor that has big impact on + * the actual factor is if there is (disk) IO outstanding or not. + * (as a special twist, we consider every sleep longer than 50 milliseconds + * as perfect; there are no power gains for sleeping longer than this) + * + * For these two reasons we keep an array of 12 independent factors, that gets + * indexed based on the magnitude of the expected duration as well as the + * "is IO outstanding" property. + * + * Repeatable-interval-detector + * ---------------------------- + * There are some cases where "next timer" is a completely unusable predictor: + * Those cases where the interval is fixed, for example due to hardware + * interrupt mitigation, but also due to fixed transfer rate devices such as + * mice. + * For this, we use a different predictor: We track the duration of the last 8 + * intervals and if the stand deviation of these 8 intervals is below a + * threshold value, we use the average of these intervals as prediction. + * + * Limiting Performance Impact + * --------------------------- + * C states, especially those with large exit latencies, can have a real + * noticeable impact on workloads, which is not acceptable for most sysadmins, + * and in addition, less performance has a power price of its own. + * + * As a general rule of thumb, power aware sched assumes that the following + * heuristic holds: + * The busier the system, the less impact of C states is acceptable + * + * This rule-of-thumb is implemented using a performance-multiplier: + * If the exit latency times the performance multiplier is longer than + * the predicted duration, the C state is not considered a candidate + * for selection due to a too high performance impact. So the higher + * this multiplier is, the longer we need to be idle to pick a deep C + * state, and thus the less likely a busy CPU will hit such a deep + * C state. + * + * Two factors are used in determing this multiplier: + * a value of 10 is added for each point of "per cpu load average" we have. + * a value of 5 points is added for each process that is waiting for + * IO on this CPU. + * (these values are experimentally determined) + * + * The load average factor gives a longer term (few seconds) input to the + * decision, while the iowait value gives a cpu local instantanious input. + * The iowait factor may look low, but realize that this is also already + * represented in the system load average. + * + */ + +struct sched_cpuidle_info { + int last_state_idx; + int needs_update; + + unsigned int next_timer_us; + unsigned int predicted_us; + unsigned int bucket; + unsigned int correction_factor[BUCKETS]; + unsigned int intervals[INTERVALS]; + int interval_ptr; +}; + + +#define LOAD_INT(x) ((x) >> FSHIFT) +#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100) + +static int get_loadavg(void) +{ + unsigned long this = this_cpu_load(); + + + return LOAD_INT(this) * 10 + LOAD_FRAC(this) / 10; +} + +static inline int which_bucket(unsigned int duration) +{ + int bucket = 0; + + /* + * We keep two groups of stats; one with no + * IO pending, one without. + * This allows us to calculate + * E(duration)|iowait + */ + if (nr_iowait_cpu(smp_processor_id())) + bucket = BUCKETS/2; + + if (duration < 10) + return bucket; + if (duration < 100) + return bucket + 1; + if (duration < 1000) + return bucket + 2; + if (duration < 10000) + return bucket + 3; + if (duration < 100000) + return bucket + 4; + return bucket + 5; +} + +/* + * Return a multiplier for the exit latency that is intended + * to take performance requirements into account. + * The more performance critical we estimate the system + * to be, the higher this multiplier, and thus the higher + * the barrier to go to an expensive C state. + */ +static inline int performance_multiplier(void) +{ + int mult = 1; + + /* for higher loadavg, we are more reluctant */ + + mult += 2 * get_loadavg(); + + /* for IO wait tasks (per cpu!) we add 5x each */ + mult += 10 * nr_iowait_cpu(smp_processor_id()); + + return mult; +} + +static DEFINE_PER_CPU(struct sched_cpuidle_info, cpuidle_info ); + +static void cpuidle_sched_update(struct cpuidle_driver *drv, + struct cpuidle_device *dev); + +/* This implements DIV_ROUND_CLOSEST but avoids 64 bit division */ +static u64 div_round64(u64 dividend, u32 divisor) +{ + return div_u64(dividend + (divisor / 2), divisor); +} + +/* + * Try detecting repeating patterns by keeping track of the last 8 + * intervals, and checking if the standard deviation of that set + * of points is below a threshold. If it is... then use the + * average of these 8 points as the estimated value. + */ +static void get_typical_interval(struct sched_cpuidle_info *data) +{ + int i, divisor; + unsigned int max, thresh; + uint64_t avg, stddev; + + thresh = UINT_MAX; /* Discard outliers above this value */ + +again: + + /* First calculate the average of past intervals */ + max = 0; + avg = 0; + divisor = 0; + for (i = 0; i < INTERVALS; i++) { + unsigned int value = data->intervals[i]; + if (value <= thresh) { + avg += value; + divisor++; + if (value > max) + max = value; + } + } + do_div(avg, divisor); + + /* Then try to determine standard deviation */ + stddev = 0; + for (i = 0; i < INTERVALS; i++) { + unsigned int value = data->intervals[i]; + if (value <= thresh) { + int64_t diff = value - avg; + stddev += diff * diff; + } + } + do_div(stddev, divisor); + /* + * The typical interval is obtained when standard deviation is small + * or standard deviation is small compared to the average interval. + * + * int_sqrt() formal parameter type is unsigned long. When the + * greatest difference to an outlier exceeds ~65 ms * sqrt(divisor) + * the resulting squared standard deviation exceeds the input domain + * of int_sqrt on platforms where unsigned long is 32 bits in size. + * In such case reject the candidate average. + * + * Use this result only if there is no timer to wake us up sooner. + */ + if (likely(stddev <= ULONG_MAX)) { + stddev = int_sqrt(stddev); + if (((avg > stddev * 6) && (divisor * 4 >= INTERVALS * 3)) + || stddev <= 20) { + if (data->next_timer_us > avg) + data->predicted_us = avg; + return; + } + } + + /* + * If we have outliers to the upside in our distribution, discard + * those by setting the threshold to exclude these outliers, then + * calculate the average and standard deviation again. Once we get + * down to the bottom 3/4 of our samples, stop excluding samples. + * + * This can deal with workloads that have long pauses interspersed + * with sporadic activity with a bunch of short pauses. + */ + if ((divisor * 4) <= INTERVALS * 3) + return; + + thresh = max - 1; + goto again; +} + +/** + * cpuidle_sched_select - selects the next idle state to enter + * @drv: cpuidle driver containing state data + * @dev: the CPU + */ +int cpuidle_sched_select(struct cpuidle_driver *drv, + struct cpuidle_device *dev) +{ + struct sched_cpuidle_info *data = &__get_cpu_var(cpuidle_info); + int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); + int i; + unsigned int interactivity_req; + struct timespec t; + + if (data->needs_update) { + cpuidle_sched_update(drv, dev); + data->needs_update = 0; + } + + data->last_state_idx = CPUIDLE_DRIVER_STATE_START - 1; + + /* Special case when user has set very strict latency requirement */ + if (unlikely(latency_req == 0)) + return 0; + + /* determine the expected residency time, round up */ + t = ktime_to_timespec(tick_nohz_get_sleep_length()); + data->next_timer_us = + t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC; + + + data->bucket = which_bucket(data->next_timer_us); + + /* + * Force the result of multiplication to be 64 bits even if both + * operands are 32 bits. + * Make sure to round up for half microseconds. + */ + data->predicted_us = div_round64((uint64_t)data->next_timer_us * + data->correction_factor[data->bucket], + RESOLUTION * DECAY); + + get_typical_interval(data); + + /* + * Performance multiplier defines a minimum predicted idle + * duration / latency ratio. Adjust the latency limit if + * necessary. + */ + interactivity_req = data->predicted_us / performance_multiplier(); + if (latency_req > interactivity_req) + latency_req = interactivity_req; + + /* + * We want to default to C1 (hlt), not to busy polling + * unless the timer is happening really really soon. + */ + if (data->next_timer_us > 5 && + !drv->states[CPUIDLE_DRIVER_STATE_START].disabled && + dev->states_usage[CPUIDLE_DRIVER_STATE_START].disable == 0) + data->last_state_idx = CPUIDLE_DRIVER_STATE_START; + + /* + * Find the idle state with the lowest power while satisfying + * our constraints. + */ + 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) + continue; + if (s->target_residency > data->predicted_us) + continue; + if (s->exit_latency > latency_req) + continue; + + data->last_state_idx = i; + } + + return data->last_state_idx; +} + +/** + * cpuidle_sched_reflect - records that data structures need update + * @dev: the CPU + * @index: the index of actual entered state + * + * NOTE: it's important to be fast here because this operation will add to + * the overall exit latency. + */ +void cpuidle_sched_reflect(struct cpuidle_device *dev, int index) +{ + struct sched_cpuidle_info *data = &__get_cpu_var(cpuidle_info); + data->last_state_idx = index; + if (index >= 0) + data->needs_update = 1; +} + +/** + * cpuidle_sched_update - attempts to guess what happened after entry + * @drv: cpuidle driver containing state data + * @dev: the CPU + */ +static void cpuidle_sched_update(struct cpuidle_driver *drv, struct cpuidle_device *dev) +{ + struct sched_cpuidle_info *data = &__get_cpu_var(cpuidle_info); + int last_idx = data->last_state_idx; + struct cpuidle_state *target = &drv->states[last_idx]; + unsigned int measured_us; + unsigned int new_factor; + + /* + * Try to figure out how much time passed between entry to low + * power state and occurrence of the wakeup event. + * + * If the entered idle state didn't support residency measurements, + * we are basically lost in the dark how much time passed. + * As a compromise, assume we slept for the whole expected time. + * + * Any measured amount of time will include the exit latency. + * Since we are interested in when the wakeup begun, not when it + * was completed, we must subtract the exit latency. However, if + * the measured amount of time is less than the exit latency, + * assume the state was never reached and the exit latency is 0. + */ + if (unlikely(!(target->flags & CPUIDLE_FLAG_TIME_VALID))) { + /* Use timer value as is */ + measured_us = data->next_timer_us; + + } else { + /* Use measured value */ + measured_us = cpuidle_get_last_residency(dev); + + /* Deduct exit latency */ + if (measured_us > target->exit_latency) + measured_us -= target->exit_latency; + + /* Make sure our coefficients do not exceed unity */ + if (measured_us > data->next_timer_us) + measured_us = data->next_timer_us; + } + + /* Update our correction ratio */ + new_factor = data->correction_factor[data->bucket]; + new_factor -= new_factor / DECAY; + + if (data->next_timer_us > 0 && measured_us < MAX_INTERESTING) + new_factor += RESOLUTION * measured_us / data->next_timer_us; + else + /* + * we were idle so long that we count it as a perfect + * prediction + */ + new_factor += RESOLUTION; + + /* + * We don't want 0 as factor; we always want at least + * a tiny bit of estimated time. Fortunately, due to rounding, + * new_factor will stay nonzero regardless of measured_us values + * and the compiler can eliminate this test as long as DECAY > 1. + */ + if (DECAY == 1 && unlikely(new_factor == 0)) + new_factor = 1; + + data->correction_factor[data->bucket] = new_factor; + + /* update the repeating-pattern data */ + data->intervals[data->interval_ptr++] = measured_us; + if (data->interval_ptr >= INTERVALS) + data->interval_ptr = 0; +} + +/** + * cpuidle_sched_enable_device - scans a CPU's states and does setup + * @drv: cpuidle driver + * @dev: the CPU + */ +int cpuidle_sched_enable_device(struct cpuidle_driver *drv, + struct cpuidle_device *dev) +{ + struct sched_cpuidle_info *data = &per_cpu(cpuidle_info, dev->cpu); + int i; + + memset(data, 0, sizeof(struct sched_cpuidle_info)); + + /* + * if the correction factor is 0 (eg first time init or cpu hotplug + * etc), we actually want to start out with a unity factor. + */ + for(i = 0; i < BUCKETS; i++) + data->correction_factor[i] = RESOLUTION * DECAY; + + return 0; +} +

The goal of the power aware scheduler design is to integrate all cpu power management in the scheduler. As a first step the idle state selection was moved into the scheduler. Doing this helps better decide which idle state to enter into using metrics known by the scheduler. However the cost of entering and exiting an idle state can help the scheduler do load balancing better.It would be even better if the idle states can let the scheduler know about the impact on the cache contents when the cpu enters that state. The scheduler can make use of this data while waking up tasks or scheduling new tasks. To make way for such information to be propogated to the scheduler, enumerate idle states in the scheduler topology levels.

Doing so will also let the scheduler know the idle states that a *sched_group* can enter into at a given level of scheduling domain. This means the scheduler is implicitly made aware of the fact that idle state is not necessarily a per-cpu state, it can be a per-core state or a state shared by a group of cpus that is specified by the sched_group. The knowledge of this higher level cpuidle information is missing today too.

The low level platform cpuidle drivers must expose to the scheduler the idle states at the different topology levels. This patch takes up the powernv cpuidle driver to illustrate this. The scheduling topology is left to the arch to decide. Commit 143e1e28cb40bed836 introduced this. The platform idle drivers are thus in a better position to fill up the topology levels with appropriate cpuidle state information while they discover it themselves.

Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

drivers/cpuidle/cpuidle-powernv.c | 8 ++++++++ include/linux/sched.h | 3 +++ 2 files changed, 11 insertions(+)

diff --git a/drivers/cpuidle/cpuidle-powernv.c b/drivers/cpuidle/cpuidle-powernv.c index 95ef533..4232fbc 100644 --- a/drivers/cpuidle/cpuidle-powernv.c +++ b/drivers/cpuidle/cpuidle-powernv.c @@ -184,6 +184,11 @@ static int powernv_add_idle_states(void)

dt_idle_states = len_flags / sizeof(u32);

+#ifdef CONFIG_SCHED_POWER + /* Snooze is a thread level idle state; the rest are core level idle states */ + sched_domain_topology[0].states[0] = powernv_states[0]; +#endif + for (i = 0; i < dt_idle_states; i++) {

flags = be32_to_cpu(idle_state_flags[i]); @@ -209,6 +214,9 @@ static int powernv_add_idle_states(void) powernv_states[nr_idle_states].enter = &fastsleep_loop; nr_idle_states++; } +#ifdef CONFIG_SCHED_POWER + sched_domain_topology[1].states[i] = powernv_states[nr_idle_states]; +#endif }

return nr_idle_states; diff --git a/include/linux/sched.h b/include/linux/sched.h index 5dd99b5..009da6a 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -1027,6 +1027,9 @@ struct sched_domain_topology_level { #ifdef CONFIG_SCHED_DEBUG char *name; #endif +#ifdef CONFIG_SCHED_POWER + struct cpuidle_state states[CPUIDLE_STATE_MAX]; +#endif };

extern struct sched_domain_topology_level *sched_domain_topology;

From: Alex Shi alex.shi@intel.com

This patch add the power aware scheduler knob into sysfs:

$cat /sys/devices/system/cpu/sched_balance_policy/available_sched_balance_policy performance powersaving $cat /sys/devices/system/cpu/sched_balance_policy/current_sched_balance_policy powersaving

This means the using sched balance policy is 'powersaving'.

User can change the policy by commend 'echo': echo performance > /sys/devices/system/cpu/sched_balance_policy/current_sched_balance_policy

Signed-off-by: Alex Shi alex.shi@intel.com [Added CONFIG_SCHED_POWER switch to enable this patch] Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

Documentation/ABI/testing/sysfs-devices-system-cpu | 23 +++++++ kernel/sched/fair.c | 69 ++++++++++++++++++++ 2 files changed, 92 insertions(+)

diff --git a/Documentation/ABI/testing/sysfs-devices-system-cpu b/Documentation/ABI/testing/sysfs-devices-system-cpu index acb9bfc..c7ed5c1 100644 --- a/Documentation/ABI/testing/sysfs-devices-system-cpu +++ b/Documentation/ABI/testing/sysfs-devices-system-cpu @@ -53,6 +53,29 @@ Description: Dynamic addition and removal of CPU's. This is not hotplug the system. Information writtento the file to remove CPU's is architecture specific.

+What: /sys/devices/system/cpu/sched_balance_policy/current_sched_balance_policy + /sys/devices/system/cpu/sched_balance_policy/available_sched_balance_policy +Date: Oct 2012 +Contact: Linux kernel mailing list linux-kernel@vger.kernel.org +Description: CFS balance policy show and set interface. + This will get activated only when CONFIG_SCHED_POWER is set. + + available_sched_balance_policy: shows there are 2 kinds of + policies: + performance powersaving. + current_sched_balance_policy: shows current scheduler policy. + User can change the policy by writing it. + + Policy decides the CFS scheduler how to balance tasks onto + different CPU unit. + + performance: try to spread tasks onto more CPU sockets, + more CPU cores. performance oriented. + + powersaving: try to pack tasks onto same core or same CPU + until every LCPUs are busy in the core or CPU socket. + powersaving oriented. + What: /sys/devices/system/cpu/cpu#/node Date: October 2009 Contact: Linux memory management mailing list linux-mm@kvack.org diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 77da534..f1b0a33 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -5863,6 +5863,75 @@ static inline int sg_imbalanced(struct sched_group *group) return group->sgc->imbalance; }

+#if defined(CONFIG_SYSFS) && defined(CONFIG_SCHED_POWER) +static ssize_t show_available_sched_balance_policy(struct device *dev, + struct device_attribute *attr, char *buf) +{ + return sprintf(buf, "performance powersaving\n"); +} + +static ssize_t show_current_sched_balance_policy(struct device *dev, + struct device_attribute *attr, char *buf) +{ + if (sched_balance_policy == SCHED_POLICY_PERFORMANCE) + return sprintf(buf, "performance\n"); + else if (sched_balance_policy == SCHED_POLICY_POWERSAVING) + return sprintf(buf, "powersaving\n"); + return 0; +} + +static ssize_t set_sched_balance_policy(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + unsigned int ret = -EINVAL; + char str_policy[16]; + + ret = sscanf(buf, "%15s", str_policy); + if (ret != 1) + return -EINVAL; + + if (!strcmp(str_policy, "performance")) + sched_balance_policy = SCHED_POLICY_PERFORMANCE; + else if (!strcmp(str_policy, "powersaving")) + sched_balance_policy = SCHED_POLICY_POWERSAVING; + else + return -EINVAL; + + return count; +} + +/* + * * Sysfs setup bits: + * */ +static DEVICE_ATTR(current_sched_balance_policy, 0644, + show_current_sched_balance_policy, set_sched_balance_policy); + +static DEVICE_ATTR(available_sched_balance_policy, 0444, + show_available_sched_balance_policy, NULL); + +static struct attribute *sched_balance_policy_default_attrs[] = { + &dev_attr_current_sched_balance_policy.attr, + &dev_attr_available_sched_balance_policy.attr, + NULL +}; +static struct attribute_group sched_balance_policy_attr_group = { + .attrs = sched_balance_policy_default_attrs, + .name = "sched_balance_policy", +}; + +int __init create_sysfs_sched_balance_policy_group(struct device *dev) +{ + return sysfs_create_group(&dev->kobj, &sched_balance_policy_attr_group); +} + +static int __init sched_balance_policy_sysfs_init(void) +{ + return create_sysfs_sched_balance_policy_group(cpu_subsys.dev_root); +} + +core_initcall(sched_balance_policy_sysfs_init); +#endif /* CONFIG_SYSFS && CONFIG_SCHED_POWER*/ + /* * Compute the group capacity factor. *

From: Alex Shi alex.shi@intel.com

For power aware balancing, we care the sched domain/group's utilization. So add: sd_lb_stats.sd_util and sg_lb_stats.group_util.

And want to know which group is busiest but still has capability to handle more tasks, so add: sd_lb_stats.group_leader

Signed-off-by: Alex Shi alex.shi@intel.com [Added CONFIG_SCHED_POWER switch to enable this patch] Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

kernel/sched/fair.c | 9 +++++++++ 1 file changed, 9 insertions(+)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 681ad06..3d6d081 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -5593,6 +5593,9 @@ struct sg_lb_stats { unsigned int nr_numa_running; unsigned int nr_preferred_running; #endif +#ifdef CONFIG_SCHED_POWER + unsigned int group_util; /* sum utilization of group */ +#endif };

/* @@ -5608,6 +5611,12 @@ struct sd_lb_stats {

struct sg_lb_stats busiest_stat;/* Statistics of the busiest group */ struct sg_lb_stats local_stat; /* Statistics of the local group */ + +#ifdef CONFIG_SCHED_POWER + /* Varibles of power aware scheduling */ + unsigned int sd_util; /* sum utilization of this domain */ + struct sched_group *group_leader; /* Group which relieves group_min */ +#endif };

static inline void init_sd_lb_stats(struct sd_lb_stats *sds)

From: Alex Shi alex.shi@intel.com

Since the rt task priority is higher than fair tasks, cfs_rq utilization is just the left of rt utilization.

When there are some cfs tasks in queue, the potential utilization may be yielded, so mulitiplying cfs task number to get max potential utilization of cfs. Then the rq utilization is sum of rt util and cfs util.

Signed-off-by: Alex Shi alex.shi@intel.com [Added CONFIG_SCHED_POWER switch to enable this patch] Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

kernel/sched/fair.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 031d115..60abaf4 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -3308,6 +3308,53 @@ static inline int throttled_hierarchy(struct cfs_rq *cfs_rq) return cfs_bandwidth_used() && cfs_rq->throttle_count; }

+#ifdef CONFIG_SCHED_POWER +static unsigned long scale_rt_util(int cpu) +{ + struct rq *rq = cpu_rq(cpu); + u64 total, age_stamp, avg; + s64 delta; + + /* + * Since we're reading these variables without serialization make sure + * we read them once before doing sanity checks on them. + */ + age_stamp = ACCESS_ONCE(rq->age_stamp); + avg = ACCESS_ONCE(rq->rt_avg); + + delta = rq_clock(rq) - age_stamp; + if (unlikely(delta < 0)) + delta = 0; + + total = sched_avg_period() + delta; + + if (unlikely(total < avg)) { + /* Ensures that capacity won't go beyond full scaled value */ + return SCHED_CAPACITY_SCALE; + } + + if (unlikely((s64)total < SCHED_CAPACITY_SCALE)) + total = SCHED_CAPACITY_SCALE; + + total >>= SCHED_CAPACITY_SHIFT; + + return div_u64(avg, total); +} + +static unsigned int max_rq_util(int cpu) +{ + struct rq *rq = cpu_rq(cpu); + unsigned int rt_util = scale_rt_util(cpu); + unsigned int cfs_util; + unsigned int nr_running; + + cfs_util = (FULL_UTIL - rt_util) > rq->util ? rq->util + : (FULL_UTIL - rt_util); + nr_running = rq->nr_running ? rq->nr_running : 1; + + return rt_util + cfs_util * nr_running; +} +#endif /* * Ensure that neither of the group entities corresponding to src_cpu or * dest_cpu are members of a throttled hierarchy when performing group

From: Alex Shi alex.shi@intel.com

This patch add power aware scheduling in fork/exec/wake. It try to select cpu from the busiest while still has utilization group. That's will save power since it leaves more groups idle in system.

The trade off is adding a power aware statistics collection in group seeking. But since the collection just happened in power scheduling eligible condition, the worst case of hackbench testing just drops about 2% with powersaving policy. No clear change for performance policy.

The main function in this patch is get_cpu_for_power_policy(), that will try to get a idlest cpu from the busiest while still has utilization group, if the system is using power aware policy and has such group.

Signed-off-by: Alex Shi alex.shi@intel.com [Added CONFIG_SCHED_POWER switch to enable this patch] Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

kernel/sched/fair.c | 117 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 114 insertions(+), 3 deletions(-)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 20e2414..e993f1c 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -4600,6 +4600,103 @@ struct sd_lb_stats { #endif };

+#ifdef CONFIG_SCHED_POWER +/* + * Try to collect the task running number and capacity of the group. + */ +static void get_sg_power_stats(struct sched_group *group, + struct sched_domain *sd, struct sg_lb_stats *sgs) +{ + int i; + + for_each_cpu(i, sched_group_cpus(group)) + sgs->group_util += max_rq_util(i); + + sgs->group_weight = group->group_weight; +} + +/* + * Is this domain full of utilization with the task? + */ +static int is_sd_full(struct sched_domain *sd, + struct task_struct *p, struct sd_lb_stats *sds) +{ + struct sched_group *group; + struct sg_lb_stats sgs; + long sd_min_delta = LONG_MAX; + unsigned int putil; + + if (p->se.load.weight == p->se.avg.load_avg_contrib) + /* p maybe a new forked task */ + putil = FULL_UTIL; + else + putil = (u64)(p->se.avg.runnable_avg_sum << SCHED_CAPACITY_SHIFT) + / (p->se.avg.runnable_avg_period + 1); + + /* Try to collect the domain's utilization */ + group = sd->groups; + do { + long g_delta; + + memset(&sgs, 0, sizeof(sgs)); + get_sg_power_stats(group, sd, &sgs); + + g_delta = sgs.group_weight * FULL_UTIL - sgs.group_util; + + if (g_delta > 0 && g_delta < sd_min_delta) { + sd_min_delta = g_delta; + sds->group_leader = group; + } + + sds->sd_util += sgs.group_util; + } while (group = group->next, group != sd->groups); + + if (sds->sd_util + putil < sd->span_weight * FULL_UTIL) + return 0; + + /* can not hold one more task in this domain */ + return 1; +} + +/* + * Execute power policy if this domain is not full. + */ +static inline int get_sd_sched_balance_policy(struct sched_domain *sd, + int cpu, struct task_struct *p, struct sd_lb_stats *sds) +{ + if (sched_balance_policy == SCHED_POLICY_PERFORMANCE) + return SCHED_POLICY_PERFORMANCE; + + memset(sds, 0, sizeof(*sds)); + if (is_sd_full(sd, p, sds)) + return SCHED_POLICY_PERFORMANCE; + return sched_balance_policy; +} + +/* + * If power policy is eligible for this domain, and it has task allowed cpu. + * we will select CPU from this domain. + */ +static int get_cpu_for_power_policy(struct sched_domain *sd, int cpu, + struct task_struct *p, struct sd_lb_stats *sds) +{ + int policy; + int new_cpu = -1; + + policy = get_sd_sched_balance_policy(sd, cpu, p, sds); + if (policy != SCHED_POLICY_PERFORMANCE && sds->group_leader) + new_cpu = find_idlest_cpu(sds->group_leader, p, cpu); + + return new_cpu; +} +#else +static int get_cpu_for_power_policy(struct sched_domain *sd, int cpu, + struct task_struct *p, struct sd_lb_stats *sds) +{ + return -1; +} +#endif /* CONFIG_SCHED_POWER */ + /* * select_task_rq_fair: Select target runqueue for the waking task in domains * that have the 'sd_flag' flag set. In practice, this is SD_BALANCE_WAKE, @@ -4608,6 +4705,9 @@ struct sd_lb_stats { * Balances load by selecting the idlest cpu in the idlest group, or under * certain conditions an idle sibling cpu if the domain has SD_WAKE_AFFINE set. * + * If CONFIG_SCHED_POWER is set and SCHED_POLICY_POWERSAVE is enabled, the power + * aware scheduler kicks in. It returns a cpu appropriate for power savings. + * * Returns the target cpu number. * * preempt must be disabled. @@ -4620,6 +4720,7 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_f int new_cpu = cpu; int want_affine = 0; int sync = wake_flags & WF_SYNC; + struct sd_lb_stats sds;

if (p->nr_cpus_allowed == 1) return prev_cpu; @@ -4645,12 +4746,22 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_f break; }

- if (tmp->flags & sd_flag) + if (tmp->flags & sd_flag) { sd = tmp; + + new_cpu = get_cpu_for_power_policy(sd, cpu, p, &sds); + if (new_cpu != -1) + goto unlock; + } } + if (affine_sd) { + new_cpu = get_cpu_for_power_policy(affine_sd, cpu, p, &sds); + if (new_cpu != -1) + goto unlock;

- if (affine_sd && cpu != prev_cpu && wake_affine(affine_sd, p, sync)) - prev_cpu = cpu; + if (cpu != prev_cpu && wake_affine(affine_sd, p, sync)) + prev_cpu = cpu; + }

if (sd_flag & SD_BALANCE_WAKE) { new_cpu = select_idle_sibling(p, prev_cpu);

From: Alex Shi alex.shi@intel.com

If the waked task is transitory enough, it will has a chance to be packed into a cpu which is busy but still has time to care it.

For powersaving policy, only the history util < 25% task has chance to be packed. If there is no cpu eligible to handle it, will use a idlest cpu in leader group.

Morten Rasmussen catch a type bug. And PeterZ reminder to consider rt_util. thanks you!

Inspired-by: Vincent Guittot vincent.guittot@linaro.org Signed-off-by: Alex Shi alex.shi@intel.com [Added CONFIG_SCHED_POWER switch to enable this patch] Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

kernel/sched/fair.c | 56 +++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 49 insertions(+), 7 deletions(-)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 3db77e8..e7a677e 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -4693,24 +4693,65 @@ static inline int get_sd_sched_balance_policy(struct sched_domain *sd, }

/* + * find_leader_cpu - find the busiest but still has enough free time cpu + * among the cpus in group. + */ +static int +find_leader_cpu(struct sched_group *group, struct task_struct *p, int this_cpu, + int policy) +{ + int vacancy, min_vacancy = INT_MAX; + int leader_cpu = -1; + int i; + /* percentage of the task's util */ + unsigned putil = (u64)(p->se.avg.runnable_avg_sum << SCHED_CAPACITY_SHIFT) + / (p->se.avg.runnable_avg_period + 1); + + /* bias toward local cpu */ + if (cpumask_test_cpu(this_cpu, tsk_cpus_allowed(p)) && + FULL_UTIL - max_rq_util(this_cpu) - (putil << 2) > 0) + return this_cpu; + + /* Traverse only the allowed CPUs */ + for_each_cpu_and(i, sched_group_cpus(group), tsk_cpus_allowed(p)) { + if (i == this_cpu) + continue; + + /* only light task allowed, putil < 25% */ + vacancy = FULL_UTIL - max_rq_util(i) - (putil << 2); + + if (vacancy > 0 && vacancy < min_vacancy) { + min_vacancy = vacancy; + leader_cpu = i; + } + } + return leader_cpu; +} + +/* * If power policy is eligible for this domain, and it has task allowed cpu. * we will select CPU from this domain. */ static int get_cpu_for_power_policy(struct sched_domain *sd, int cpu, - struct task_struct *p, struct sd_lb_stats *sds) + struct task_struct *p, struct sd_lb_stats *sds, int wakeup) { int policy; int new_cpu = -1;

policy = get_sd_sched_balance_policy(sd, cpu, p, sds); - if (policy != SCHED_POLICY_PERFORMANCE && sds->group_leader) - new_cpu = find_idlest_cpu(sds->group_leader, p, cpu); - + if (policy != SCHED_POLICY_PERFORMANCE && sds->group_leader) { + if (wakeup) + new_cpu = find_leader_cpu(sds->group_leader, + p, cpu, policy); + /* for fork balancing and a little busy task */ + if (new_cpu == -1) + new_cpu = find_idlest_cpu(sds->group_leader, p, cpu); + } return new_cpu; } #else static int get_cpu_for_power_policy(struct sched_domain *sd, int cpu, - struct task_struct *p, struct sd_lb_stats *sds) + struct task_struct *p, struct sd_lb_stats *sds, int wakeup) { return -1; } @@ -4768,13 +4809,14 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int sd_flag, int wake_f if (tmp->flags & sd_flag) { sd = tmp;

- new_cpu = get_cpu_for_power_policy(sd, cpu, p, &sds); + new_cpu = get_cpu_for_power_policy(sd, cpu, p, &sds, + sd_flag & SD_BALANCE_WAKE); if (new_cpu != -1) goto unlock; } } if (affine_sd) { - new_cpu = get_cpu_for_power_policy(affine_sd, cpu, p, &sds); + new_cpu = get_cpu_for_power_policy(affine_sd, cpu, p, &sds, 1); if (new_cpu != -1) goto unlock;

From: Alex Shi alex.shi@intel.com

In power balance, we hope some sched groups are fully empty to save CPU power of them. So, we want to move any tasks from them.

Also in power aware scheduling, we don't want to balance 'prefer_sibling' groups just because local group has capacity. If the local group has no tasks at the time, that is the power balance hope so.

Signed-off-by: Alex Shi alex.shi@intel.com [Added CONFIG_SCHED_POWER switch to enable this patch] Signed-off-by: Preeti U Murthy preeti@linux.vnet.ibm.com ---

kernel/sched/fair.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 49 insertions(+), 2 deletions(-)

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index f9b2a21..fd93eaf 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -6346,6 +6346,21 @@ static inline enum fbq_type fbq_classify_rq(struct rq *rq) } #endif /* CONFIG_NUMA_BALANCING */

+#ifdef CONFIG_SCHED_POWER +static int get_power_policy(struct lb_env *env) +{ + if (env->flags & LBF_PERF_BAL) + return 0; + else + return 1; +} +#else +static int get_power_policy(struct lb_env *env) +{ + return 0; +} +#endif /* CONFIG_SCHED_POWER */ + /** * update_sd_lb_stats - Update sched_domain's statistics for load balancing. * @env: The load balancing environment. @@ -6358,6 +6373,7 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd struct sg_lb_stats tmp_sgs; int load_idx, prefer_sibling = 0; bool overload = false; + int powersave = 0;

if (child && child->flags & SD_PREFER_SIBLING) prefer_sibling = 1; @@ -6393,9 +6409,14 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd * extra check prevents the case where you always pull from the * heaviest group when it is already under-utilized (possible * with a large weight task outweighs the tasks on the system). + * + * In power aware scheduling, we don't care load weight and + * want not to pull tasks just because local group has capacity. */ + powersave = get_power_policy(env); + if (prefer_sibling && sds->local && - sds->local_stat.group_has_free_capacity) + sds->local_stat.group_has_free_capacity && !powersave) sgs->group_capacity_factor = min(sgs->group_capacity_factor, 1U);

if (update_sd_pick_busiest(env, sds, sg, sgs)) { @@ -6761,8 +6782,15 @@ static struct rq *find_busiest_queue(struct lb_env *env, * When comparing with imbalance, use weighted_cpuload() * which is not scaled with the cpu capacity. */ +#ifdef CONFIG_SCHED_POWER + if (rq->nr_running == 0 || + (!(env->flags & LBF_POWER_BAL) && capacity_factor && + rq->nr_running == 1 && wl > env->imbalance)) + continue; +#else if (capacity_factor && rq->nr_running == 1 && wl > env->imbalance) continue; +#endif /* CONFIG_SCHED_POWER */

/* * For the load comparisons with the other cpu's, consider @@ -6848,6 +6876,25 @@ static int should_we_balance(struct lb_env *env) return balance_cpu == env->dst_cpu; }

+#ifdef CONFIG_SCHED_POWER +static int is_busiest_eligible(struct rq *rq, struct lb_env *env) +{ + if (rq->nr_running > 1 || + (rq->nr_running == 1 && env->flags & LBF_POWER_BAL)) + return 1; + else + return 0; +} +#else +static int is_busiest_eligible(struct rq *rq, struct lb_env *env) +{ + if (rq->nr_running > 1) + return 1; + else + return 0; +} +#endif /* CONFIG_SCHED_POWER */ + /* * Check this_cpu to ensure it is balanced within domain. Attempt to move * tasks if there is an imbalance. @@ -6911,7 +6958,7 @@ redo: schedstat_add(sd, lb_imbalance[idle], env.imbalance);

ld_moved = 0; - if (busiest->nr_running > 1) { + if (is_busiest_eligible(busiest, &env)) { /* * Attempt to move tasks. If find_busiest_group has found * an imbalance but busiest->nr_running <= 1, the group is