This layer provides Energy Aware Scheduling (EAS) patcheseel_5.1.0eel_5.0.3eel_5.0.2eel/5.1.0eel/5.0.3eel/5.0.25.1.05.0.35.0.2eel

For the moment only for Renesas R-Car Gen3 SoC's.
Can be expanded for other SoC's by setting the machine
feature biglittle and provide the relevant EAS patches.

Bug-AGL: SPEC-813

Change-Id: I2b5e69c515c33e57be19b30466fe208d7b8ac1a5
Signed-off-by: Frode Isaksen <fisaksen@baylibre.com>

1 files changed, 229 insertions, 0 deletions

diff --git a/meta-eas/recipes-kernel/linux/linux-renesas/0053-sched-Calculate-energy-consumption-of-sched_group.patch b/meta-eas/recipes-kernel/linux/linux-renesas/0053-sched-Calculate-energy-consumption-of-sched_group.patch
new file mode 100644
index 0000000..2f82044
--- /dev/null
+++ b/meta-eas/recipes-kernel/linux/linux-renesas/0053-sched-Calculate-energy-consumption-of-sched_group.patch
@@ -0,0 +1,229 @@
+From 1e9ffadc70a89ede023b79139debe4f6a17c5c7f Mon Sep 17 00:00:00 2001
+From: Morten Rasmussen <morten.rasmussen@arm.com>
+Date: Thu, 18 Dec 2014 14:47:18 +0000
+Subject: [PATCH 53/92] sched: Calculate energy consumption of sched_group
+
+For energy-aware load-balancing decisions it is necessary to know the
+energy consumption estimates of groups of cpus. This patch introduces a
+basic function, sched_group_energy(), which estimates the energy
+consumption of the cpus in the group and any resources shared by the
+members of the group.
+
+NOTE: The function has five levels of identation and breaks the 80
+character limit. Refactoring is necessary.
+
+cc: Ingo Molnar <mingo@redhat.com>
+cc: Peter Zijlstra <peterz@infradead.org>
+Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
+(cherry picked from commit 1e09b216da57376d8321459eda52699cef8f7e1a)
+Signed-off-by: Gaku Inami <gaku.inami.xw@bp.renesas.com>
+---
+ kernel/sched/core.c  |   4 ++
+ kernel/sched/fair.c  | 156 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ kernel/sched/sched.h |   1 +
+ 3 files changed, 161 insertions(+)
+
+diff --git a/kernel/sched/core.c b/kernel/sched/core.c
+index f2642d4..431c7e0 100644
+--- a/kernel/sched/core.c
++++ b/kernel/sched/core.c
+@@ -6002,6 +6002,7 @@ static void destroy_sched_domains(struct sched_domain *sd)
+ DEFINE_PER_CPU(struct sched_domain *, sd_numa);
+ DEFINE_PER_CPU(struct sched_domain *, sd_asym);
+ DEFINE_PER_CPU(struct sched_domain *, sd_ea);
++DEFINE_PER_CPU(struct sched_domain *, sd_scs);
+ 
+ static void update_top_cache_domain(int cpu)
+ {
+@@ -6036,6 +6037,9 @@ static void update_top_cache_domain(int cpu)
+ 			break;
+ 	}
+ 	rcu_assign_pointer(per_cpu(sd_ea, cpu), ea_sd);
++
++	sd = highest_flag_domain(cpu, SD_SHARE_CAP_STATES);
++	rcu_assign_pointer(per_cpu(sd_scs, cpu), sd);
+ }
+ 
+ /*
+diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
+index 0085d4f..1b8dca7 100644
+--- a/kernel/sched/fair.c
++++ b/kernel/sched/fair.c
+@@ -5331,6 +5331,162 @@ static inline bool energy_aware(void)
+ }
+ 
+ /*
++ * cpu_norm_util() returns the cpu util relative to a specific capacity,
++ * i.e. it's busy ratio, in the range [0..SCHED_CAPACITY_SCALE] which is useful
++ * for energy calculations. Using the scale-invariant util returned by
++ * cpu_util() and approximating scale-invariant util by:
++ *
++ *   util ~ (curr_freq/max_freq)*1024 * capacity_orig/1024 * running_time/time
++ *
++ * the normalized util can be found using the specific capacity.
++ *
++ *   capacity = capacity_orig * curr_freq/max_freq
++ *
++ *   norm_util = running_time/time ~ util/capacity
++ */
++static unsigned long cpu_norm_util(int cpu, unsigned long capacity)
++{
++	int util = cpu_util(cpu);
++
++	if (util >= capacity)
++		return SCHED_CAPACITY_SCALE;
++
++	return (util << SCHED_CAPACITY_SHIFT)/capacity;
++}
++
++static unsigned long group_max_util(struct sched_group *sg)
++{
++	int i;
++	unsigned long max_util = 0;
++
++	for_each_cpu(i, sched_group_cpus(sg))
++		max_util = max(max_util, cpu_util(i));
++
++	return max_util;
++}
++
++/*
++ * group_norm_util() returns the approximated group util relative to it's
++ * current capacity (busy ratio) in the range [0..SCHED_CAPACITY_SCALE] for use
++ * in energy calculations. Since task executions may or may not overlap in time
++ * in the group the true normalized util is between max(cpu_norm_util(i)) and
++ * sum(cpu_norm_util(i)) when iterating over all cpus in the group, i. The
++ * latter is used as the estimate as it leads to a more pessimistic energy
++ * estimate (more busy).
++ */
++static unsigned long group_norm_util(struct sched_group *sg, int cap_idx)
++{
++	int i;
++	unsigned long util_sum = 0;
++	unsigned long capacity = sg->sge->cap_states[cap_idx].cap;
++
++	for_each_cpu(i, sched_group_cpus(sg))
++		util_sum += cpu_norm_util(i, capacity);
++
++	if (util_sum > SCHED_CAPACITY_SCALE)
++		return SCHED_CAPACITY_SCALE;
++	return util_sum;
++}
++
++static int find_new_capacity(struct sched_group *sg,
++	const struct sched_group_energy const *sge)
++{
++	int idx;
++	unsigned long util = group_max_util(sg);
++
++	for (idx = 0; idx < sge->nr_cap_states; idx++) {
++		if (sge->cap_states[idx].cap >= util)
++			return idx;
++	}
++
++	return idx;
++}
++
++/*
++ * sched_group_energy(): Computes the absolute energy consumption of cpus
++ * belonging to the sched_group including shared resources shared only by
++ * members of the group. Iterates over all cpus in the hierarchy below the
++ * sched_group starting from the bottom working it's way up before going to
++ * the next cpu until all cpus are covered at all levels. The current
++ * implementation is likely to gather the same util statistics multiple times.
++ * This can probably be done in a faster but more complex way.
++ * Note: sched_group_energy() may fail when racing with sched_domain updates.
++ */
++static int sched_group_energy(struct sched_group *sg_top)
++{
++	struct sched_domain *sd;
++	int cpu, total_energy = 0;
++	struct cpumask visit_cpus;
++	struct sched_group *sg;
++
++	WARN_ON(!sg_top->sge);
++
++	cpumask_copy(&visit_cpus, sched_group_cpus(sg_top));
++
++	while (!cpumask_empty(&visit_cpus)) {
++		struct sched_group *sg_shared_cap = NULL;
++
++		cpu = cpumask_first(&visit_cpus);
++
++		/*
++		 * Is the group utilization affected by cpus outside this
++		 * sched_group?
++		 */
++		sd = rcu_dereference(per_cpu(sd_scs, cpu));
++
++		if (!sd)
++			/*
++			 * We most probably raced with hotplug; returning a
++			 * wrong energy estimation is better than entering an
++			 * infinite loop.
++			 */
++			return -EINVAL;
++
++		if (sd->parent)
++			sg_shared_cap = sd->parent->groups;
++
++		for_each_domain(cpu, sd) {
++			sg = sd->groups;
++
++			/* Has this sched_domain already been visited? */
++			if (sd->child && group_first_cpu(sg) != cpu)
++				break;
++
++			do {
++				struct sched_group *sg_cap_util;
++				unsigned long group_util;
++				int sg_busy_energy, sg_idle_energy, cap_idx;
++
++				if (sg_shared_cap && sg_shared_cap->group_weight >= sg->group_weight)
++					sg_cap_util = sg_shared_cap;
++				else
++					sg_cap_util = sg;
++
++				cap_idx = find_new_capacity(sg_cap_util, sg->sge);
++				group_util = group_norm_util(sg, cap_idx);
++				sg_busy_energy = (group_util * sg->sge->cap_states[cap_idx].power)
++										>> SCHED_CAPACITY_SHIFT;
++				sg_idle_energy = ((SCHED_CAPACITY_SCALE-group_util) * sg->sge->idle_states[0].power)
++										>> SCHED_CAPACITY_SHIFT;
++
++				total_energy += sg_busy_energy + sg_idle_energy;
++
++				if (!sd->child)
++					cpumask_xor(&visit_cpus, &visit_cpus, sched_group_cpus(sg));
++
++				if (cpumask_equal(sched_group_cpus(sg), sched_group_cpus(sg_top)))
++					goto next_cpu;
++
++			} while (sg = sg->next, sg != sd->groups);
++		}
++next_cpu:
++		continue;
++	}
++
++	return total_energy;
++}
++
++/*
+  * Detect M:N waker/wakee relationships via a switching-frequency heuristic.
+  *
+  * A waker of many should wake a different task than the one last awakened
+diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
+index 22b7cfd..75dcd85 100644
+--- a/kernel/sched/sched.h
++++ b/kernel/sched/sched.h
+@@ -893,6 +893,7 @@ static inline struct sched_domain *lowest_flag_domain(int cpu, int flag)
+ DECLARE_PER_CPU(struct sched_domain *, sd_numa);
+ DECLARE_PER_CPU(struct sched_domain *, sd_asym);
+ DECLARE_PER_CPU(struct sched_domain *, sd_ea);
++DECLARE_PER_CPU(struct sched_domain *, sd_scs);
+ 
+ struct sched_group_capacity {
+ 	atomic_t ref;
+-- 
+1.9.1
+