* [PATCH 2/4] arm64: topology: Add support for topology DT bindings
2014-04-22 20:21 [PATCH 1/4] arm64: topology: Initialise default topology state immediately Mark Brown
@ 2014-04-22 20:21 ` Mark Brown
2014-04-24 14:48 ` Lorenzo Pieralisi
2014-04-22 20:21 ` [PATCH 3/4] arm64: topology: Tell the scheduler about the relative power of cores Mark Brown
` (2 subsequent siblings)
3 siblings, 1 reply; 7+ messages in thread
From: Mark Brown @ 2014-04-22 20:21 UTC (permalink / raw)
To: linux-arm-kernel
From: Mark Brown <broonie@linaro.org>
Add support for parsing the explicit topology bindings to discover the
topology of the system.
Since it is not currently clear how to map multi-level clusters for the
scheduler all leaf clusters are presented to the scheduler at the same
level. This should be enough to provide good support for current systems.
Signed-off-by: Mark Brown <broonie@linaro.org>
---
arch/arm64/kernel/topology.c | 203 +++++++++++++++++++++++++++++++++++++++++--
1 file changed, 195 insertions(+), 8 deletions(-)
diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
index ff662b23af5f..a326f5b37546 100644
--- a/arch/arm64/kernel/topology.c
+++ b/arch/arm64/kernel/topology.c
@@ -17,10 +17,191 @@
#include <linux/percpu.h>
#include <linux/node.h>
#include <linux/nodemask.h>
+#include <linux/of.h>
#include <linux/sched.h>
#include <asm/topology.h>
+static int __init get_cpu_for_node(struct device_node *node)
+{
+ struct device_node *cpu_node;
+ int cpu;
+
+ cpu_node = of_parse_phandle(node, "cpu", 0);
+ if (!cpu_node)
+ return -1;
+
+ for_each_possible_cpu(cpu)
+ if (of_get_cpu_node(cpu, NULL) == cpu_node) {
+ of_node_put(cpu_node);
+ return cpu;
+ }
+
+ pr_crit("Unable to find CPU node for %s\n", cpu_node->full_name);
+
+ of_node_put(cpu_node);
+ return -1;
+}
+
+static int __init parse_core(struct device_node *core, int cluster_id,
+ int core_id)
+{
+ char name[10];
+ bool leaf = true;
+ int i = 0;
+ int cpu;
+ struct device_node *t;
+
+ do {
+ snprintf(name, sizeof(name), "thread%d", i);
+ t = of_get_child_by_name(core, name);
+ if (t) {
+ leaf = false;
+ cpu = get_cpu_for_node(t);
+ if (cpu >= 0) {
+ cpu_topology[cpu].cluster_id = cluster_id;
+ cpu_topology[cpu].core_id = core_id;
+ cpu_topology[cpu].thread_id = i;
+ } else {
+ pr_err("%s: Can't get CPU for thread\n",
+ t->full_name);
+ of_node_put(t);
+ return -EINVAL;
+ }
+ of_node_put(t);
+ }
+ i++;
+ } while (t);
+
+ cpu = get_cpu_for_node(core);
+ if (cpu >= 0) {
+ if (!leaf) {
+ pr_err("%s: Core has both threads and CPU\n",
+ core->full_name);
+ return -EINVAL;
+ }
+
+ cpu_topology[cpu].cluster_id = cluster_id;
+ cpu_topology[cpu].core_id = core_id;
+ } else if (leaf) {
+ pr_err("%s: Can't get CPU for leaf core\n", core->full_name);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int __init parse_cluster(struct device_node *cluster, int depth)
+{
+ char name[10];
+ bool leaf = true;
+ bool has_cores = false;
+ struct device_node *c;
+ static int cluster_id __initdata;
+ int core_id = 0;
+ int i, ret;
+
+ /*
+ * First check for child clusters; we currently ignore any
+ * information about the nesting of clusters and present the
+ * scheduler with a flat list of them.
+ */
+ i = 0;
+ do {
+ snprintf(name, sizeof(name), "cluster%d", i);
+ c = of_get_child_by_name(cluster, name);
+ if (c) {
+ leaf = false;
+ ret = parse_cluster(c, depth + 1);
+ of_node_put(c);
+ if (ret != 0)
+ return ret;
+ }
+ i++;
+ } while (c);
+
+ /* Now check for cores */
+ i = 0;
+ do {
+ snprintf(name, sizeof(name), "core%d", i);
+ c = of_get_child_by_name(cluster, name);
+ if (c) {
+ has_cores = true;
+
+ if (depth == 0) {
+ pr_err("%s: cpu-map children should be clusters\n",
+ c->full_name);
+ of_node_put(c);
+ return -EINVAL;
+ }
+
+ if (leaf) {
+ ret = parse_core(c, cluster_id, core_id++);
+ } else {
+ pr_err("%s: Non-leaf cluster with core %s\n",
+ cluster->full_name, name);
+ ret = -EINVAL;
+ }
+
+ of_node_put(c);
+ if (ret != 0)
+ return ret;
+ }
+ i++;
+ } while (c);
+
+ if (leaf && !has_cores)
+ pr_warn("%s: empty cluster\n", cluster->full_name);
+
+ if (leaf)
+ cluster_id++;
+
+ return 0;
+}
+
+static int __init parse_dt_topology(void)
+{
+ struct device_node *cn, *map;
+ int ret = 0;
+ int cpu;
+
+ cn = of_find_node_by_path("/cpus");
+ if (!cn) {
+ pr_err("No CPU information found in DT\n");
+ return 0;
+ }
+
+ /*
+ * When topology is provided cpu-map is essentially a root
+ * cluster with restricted subnodes.
+ */
+ map = of_get_child_by_name(cn, "cpu-map");
+ if (!map)
+ goto out;
+
+ ret = parse_cluster(map, 0);
+ if (ret != 0)
+ goto out_map;
+
+ /*
+ * Check that all cores are in the topology; the SMP code will
+ * only mark cores described in the DT as possible.
+ */
+ for_each_possible_cpu(cpu) {
+ if (cpu_topology[cpu].cluster_id == -1) {
+ pr_err("CPU%d: No topology information specified\n",
+ cpu);
+ ret = -EINVAL;
+ }
+ }
+
+out_map:
+ of_node_put(map);
+out:
+ of_node_put(cn);
+ return ret;
+}
+
/*
* cpu topology table
*/
@@ -39,8 +220,7 @@ static void update_siblings_masks(unsigned int cpuid)
if (cpuid_topo->cluster_id == -1) {
/*
- * DT does not contain topology information for this cpu
- * reset it to default behaviour
+ * DT does not contain topology information for this cpu.
*/
pr_debug("CPU%u: No topology information configured\n", cpuid);
return;
@@ -71,15 +251,10 @@ void store_cpu_topology(unsigned int cpuid)
update_siblings_masks(cpuid);
}
-/*
- * init_cpu_topology is called at boot when only one cpu is running
- * which prevent simultaneous write access to cpu_topology array
- */
-void __init init_cpu_topology(void)
+static void __init reset_cpu_topology(void)
{
unsigned int cpu;
- /* init core mask and power*/
for_each_possible_cpu(cpu) {
struct cpu_topology *cpu_topo = &cpu_topology[cpu];
@@ -93,3 +268,15 @@ void __init init_cpu_topology(void)
cpumask_set_cpu(cpu, &cpu_topo->thread_sibling);
}
}
+
+void __init init_cpu_topology(void)
+{
+ reset_cpu_topology();
+
+ /*
+ * Discard anything that was parsed if we hit an error so we
+ * don't use partial information.
+ */
+ if (parse_dt_topology())
+ reset_cpu_topology();
+}
--
1.9.2
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH 2/4] arm64: topology: Add support for topology DT bindings
2014-04-22 20:21 ` [PATCH 2/4] arm64: topology: Add support for topology DT bindings Mark Brown
@ 2014-04-24 14:48 ` Lorenzo Pieralisi
0 siblings, 0 replies; 7+ messages in thread
From: Lorenzo Pieralisi @ 2014-04-24 14:48 UTC (permalink / raw)
To: linux-arm-kernel
On Tue, Apr 22, 2014 at 09:21:16PM +0100, Mark Brown wrote:
> From: Mark Brown <broonie@linaro.org>
>
> Add support for parsing the explicit topology bindings to discover the
> topology of the system.
>
> Since it is not currently clear how to map multi-level clusters for the
> scheduler all leaf clusters are presented to the scheduler at the same
> level. This should be enough to provide good support for current systems.
>
> Signed-off-by: Mark Brown <broonie@linaro.org>
> ---
> arch/arm64/kernel/topology.c | 203 +++++++++++++++++++++++++++++++++++++++++--
> 1 file changed, 195 insertions(+), 8 deletions(-)
>
> diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
> index ff662b23af5f..a326f5b37546 100644
> --- a/arch/arm64/kernel/topology.c
> +++ b/arch/arm64/kernel/topology.c
> @@ -17,10 +17,191 @@
> #include <linux/percpu.h>
> #include <linux/node.h>
> #include <linux/nodemask.h>
> +#include <linux/of.h>
> #include <linux/sched.h>
>
> #include <asm/topology.h>
>
> +static int __init get_cpu_for_node(struct device_node *node)
> +{
> + struct device_node *cpu_node;
> + int cpu;
> +
> + cpu_node = of_parse_phandle(node, "cpu", 0);
> + if (!cpu_node)
> + return -1;
> +
> + for_each_possible_cpu(cpu)
> + if (of_get_cpu_node(cpu, NULL) == cpu_node) {
> + of_node_put(cpu_node);
> + return cpu;
> + }
> +
> + pr_crit("Unable to find CPU node for %s\n", cpu_node->full_name);
> +
> + of_node_put(cpu_node);
> + return -1;
> +}
> +
> +static int __init parse_core(struct device_node *core, int cluster_id,
> + int core_id)
> +{
> + char name[10];
> + bool leaf = true;
> + int i = 0;
> + int cpu;
> + struct device_node *t;
> +
> + do {
> + snprintf(name, sizeof(name), "thread%d", i);
> + t = of_get_child_by_name(core, name);
> + if (t) {
> + leaf = false;
> + cpu = get_cpu_for_node(t);
> + if (cpu >= 0) {
> + cpu_topology[cpu].cluster_id = cluster_id;
> + cpu_topology[cpu].core_id = core_id;
> + cpu_topology[cpu].thread_id = i;
> + } else {
> + pr_err("%s: Can't get CPU for thread\n",
> + t->full_name);
> + of_node_put(t);
> + return -EINVAL;
> + }
> + of_node_put(t);
> + }
> + i++;
> + } while (t);
> +
> + cpu = get_cpu_for_node(core);
> + if (cpu >= 0) {
> + if (!leaf) {
> + pr_err("%s: Core has both threads and CPU\n",
> + core->full_name);
> + return -EINVAL;
> + }
> +
> + cpu_topology[cpu].cluster_id = cluster_id;
> + cpu_topology[cpu].core_id = core_id;
> + } else if (leaf) {
> + pr_err("%s: Can't get CPU for leaf core\n", core->full_name);
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static int __init parse_cluster(struct device_node *cluster, int depth)
> +{
> + char name[10];
> + bool leaf = true;
> + bool has_cores = false;
> + struct device_node *c;
> + static int cluster_id __initdata;
> + int core_id = 0;
> + int i, ret;
> +
> + /*
> + * First check for child clusters; we currently ignore any
> + * information about the nesting of clusters and present the
> + * scheduler with a flat list of them.
> + */
> + i = 0;
> + do {
> + snprintf(name, sizeof(name), "cluster%d", i);
> + c = of_get_child_by_name(cluster, name);
> + if (c) {
> + leaf = false;
> + ret = parse_cluster(c, depth + 1);
> + of_node_put(c);
> + if (ret != 0)
> + return ret;
> + }
> + i++;
> + } while (c);
> +
> + /* Now check for cores */
> + i = 0;
> + do {
> + snprintf(name, sizeof(name), "core%d", i);
> + c = of_get_child_by_name(cluster, name);
> + if (c) {
> + has_cores = true;
> +
> + if (depth == 0) {
> + pr_err("%s: cpu-map children should be clusters\n",
> + c->full_name);
> + of_node_put(c);
> + return -EINVAL;
> + }
> +
> + if (leaf) {
> + ret = parse_core(c, cluster_id, core_id++);
> + } else {
> + pr_err("%s: Non-leaf cluster with core %s\n",
> + cluster->full_name, name);
> + ret = -EINVAL;
> + }
> +
> + of_node_put(c);
> + if (ret != 0)
> + return ret;
> + }
> + i++;
> + } while (c);
> +
> + if (leaf && !has_cores)
> + pr_warn("%s: empty cluster\n", cluster->full_name);
> +
> + if (leaf)
> + cluster_id++;
> +
> + return 0;
> +}
> +
> +static int __init parse_dt_topology(void)
> +{
> + struct device_node *cn, *map;
> + int ret = 0;
> + int cpu;
> +
> + cn = of_find_node_by_path("/cpus");
> + if (!cn) {
> + pr_err("No CPU information found in DT\n");
> + return 0;
> + }
> +
> + /*
> + * When topology is provided cpu-map is essentially a root
> + * cluster with restricted subnodes.
> + */
> + map = of_get_child_by_name(cn, "cpu-map");
> + if (!map)
> + goto out;
> +
> + ret = parse_cluster(map, 0);
> + if (ret != 0)
> + goto out_map;
> +
> + /*
> + * Check that all cores are in the topology; the SMP code will
> + * only mark cores described in the DT as possible.
> + */
> + for_each_possible_cpu(cpu) {
> + if (cpu_topology[cpu].cluster_id == -1) {
> + pr_err("CPU%d: No topology information specified\n",
> + cpu);
> + ret = -EINVAL;
> + }
> + }
> +
> +out_map:
> + of_node_put(map);
> +out:
> + of_node_put(cn);
> + return ret;
> +}
> +
> /*
> * cpu topology table
> */
> @@ -39,8 +220,7 @@ static void update_siblings_masks(unsigned int cpuid)
>
> if (cpuid_topo->cluster_id == -1) {
> /*
> - * DT does not contain topology information for this cpu
> - * reset it to default behaviour
> + * DT does not contain topology information for this cpu.
> */
> pr_debug("CPU%u: No topology information configured\n", cpuid);
> return;
> @@ -71,15 +251,10 @@ void store_cpu_topology(unsigned int cpuid)
> update_siblings_masks(cpuid);
> }
>
> -/*
> - * init_cpu_topology is called at boot when only one cpu is running
> - * which prevent simultaneous write access to cpu_topology array
> - */
> -void __init init_cpu_topology(void)
> +static void __init reset_cpu_topology(void)
> {
> unsigned int cpu;
>
> - /* init core mask and power*/
> for_each_possible_cpu(cpu) {
> struct cpu_topology *cpu_topo = &cpu_topology[cpu];
>
> @@ -93,3 +268,15 @@ void __init init_cpu_topology(void)
> cpumask_set_cpu(cpu, &cpu_topo->thread_sibling);
> }
> }
> +
> +void __init init_cpu_topology(void)
> +{
> + reset_cpu_topology();
> +
> + /*
> + * Discard anything that was parsed if we hit an error so we
> + * don't use partial information.
> + */
> + if (parse_dt_topology())
> + reset_cpu_topology();
> +}
I tested it and tried to clobber it a bit with some DT changes, it seems
fine.
Apart from an ultra-minor decoration change (attached):
Reviewed-by: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: 0001-arm64-kernel-topology-minor-cosmetic-changes.patch
Type: text/x-diff
Size: 1008 bytes
Desc: not available
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140424/75fec107/attachment.bin>
^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH 3/4] arm64: topology: Tell the scheduler about the relative power of cores
2014-04-22 20:21 [PATCH 1/4] arm64: topology: Initialise default topology state immediately Mark Brown
2014-04-22 20:21 ` [PATCH 2/4] arm64: topology: Add support for topology DT bindings Mark Brown
@ 2014-04-22 20:21 ` Mark Brown
2014-04-22 20:21 ` [PATCH 4/4] arm64: topology: Provide relative power numbers for cores Mark Brown
2014-04-24 14:39 ` [PATCH 1/4] arm64: topology: Initialise default topology state immediately Lorenzo Pieralisi
3 siblings, 0 replies; 7+ messages in thread
From: Mark Brown @ 2014-04-22 20:21 UTC (permalink / raw)
To: linux-arm-kernel
From: Mark Brown <broonie@linaro.org>
In heterogeneous systems like big.LITTLE systems the scheduler will be
able to make better use of the available cores if we provide power numbers
to it indicating their relative performance. Do this by parsing the CPU
nodes in the DT.
This code currently has no effect as no information on the relative
performance of the cores is provided.
Signed-off-by: Mark Brown <broonie@linaro.org>
---
arch/arm64/kernel/topology.c | 153 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 153 insertions(+)
diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
index a326f5b37546..a912f3a7c804 100644
--- a/arch/arm64/kernel/topology.c
+++ b/arch/arm64/kernel/topology.c
@@ -19,9 +19,33 @@
#include <linux/nodemask.h>
#include <linux/of.h>
#include <linux/sched.h>
+#include <linux/slab.h>
#include <asm/topology.h>
+/*
+ * cpu power table
+ * This per cpu data structure describes the relative capacity of each core.
+ * On a heteregenous system, cores don't have the same computation capacity
+ * and we reflect that difference in the cpu_power field so the scheduler can
+ * take this difference into account during load balance. A per cpu structure
+ * is preferred because each CPU updates its own cpu_power field during the
+ * load balance except for idle cores. One idle core is selected to run the
+ * rebalance_domains for all idle cores and the cpu_power can be updated
+ * during this sequence.
+ */
+static DEFINE_PER_CPU(unsigned long, cpu_scale);
+
+unsigned long arch_scale_freq_power(struct sched_domain *sd, int cpu)
+{
+ return per_cpu(cpu_scale, cpu);
+}
+
+static void set_power_scale(unsigned int cpu, unsigned long power)
+{
+ per_cpu(cpu_scale, cpu) = power;
+}
+
static int __init get_cpu_for_node(struct device_node *node)
{
struct device_node *cpu_node;
@@ -159,6 +183,38 @@ static int __init parse_cluster(struct device_node *cluster, int depth)
return 0;
}
+struct cpu_efficiency {
+ const char *compatible;
+ unsigned long efficiency;
+};
+
+/*
+ * Table of relative efficiency of each processors
+ * The efficiency value must fit in 20bit and the final
+ * cpu_scale value must be in the range
+ * 0 < cpu_scale < 3*SCHED_POWER_SCALE/2
+ * in order to return@most 1 when DIV_ROUND_CLOSEST
+ * is used to compute the capacity of a CPU.
+ * Processors that are not defined in the table,
+ * use the default SCHED_POWER_SCALE value for cpu_scale.
+ */
+static const struct cpu_efficiency table_efficiency[] = {
+ { NULL, },
+};
+
+static unsigned long *__cpu_capacity;
+#define cpu_capacity(cpu) __cpu_capacity[cpu]
+
+static unsigned long middle_capacity = 1;
+
+/*
+ * Iterate all CPUs' descriptor in DT and compute the efficiency
+ * (as per table_efficiency). Also calculate a middle efficiency
+ * as close as possible to (max{eff_i} - min{eff_i}) / 2
+ * This is later used to scale the cpu_power field such that an
+ * 'average' CPU is of middle power. Also see the comments near
+ * table_efficiency[] and update_cpu_power().
+ */
static int __init parse_dt_topology(void)
{
struct device_node *cn, *map;
@@ -202,6 +258,91 @@ out:
return ret;
}
+static void __init parse_dt_cpu_power(void)
+{
+ const struct cpu_efficiency *cpu_eff;
+ struct device_node *cn;
+ unsigned long min_capacity = ULONG_MAX;
+ unsigned long max_capacity = 0;
+ unsigned long capacity = 0;
+ int cpu;
+
+ __cpu_capacity = kcalloc(nr_cpu_ids, sizeof(*__cpu_capacity),
+ GFP_NOWAIT);
+
+ for_each_possible_cpu(cpu) {
+ const u32 *rate;
+ int len;
+
+ /* Too early to use cpu->of_node */
+ cn = of_get_cpu_node(cpu, NULL);
+ if (!cn) {
+ pr_err("Missing device node for CPU %d\n", cpu);
+ continue;
+ }
+
+ for (cpu_eff = table_efficiency; cpu_eff->compatible; cpu_eff++)
+ if (of_device_is_compatible(cn, cpu_eff->compatible))
+ break;
+
+ if (cpu_eff->compatible == NULL) {
+ pr_warn("%s: Unknown CPU type\n", cn->full_name);
+ continue;
+ }
+
+ rate = of_get_property(cn, "clock-frequency", &len);
+ if (!rate || len != 4) {
+ pr_err("%s: Missing clock-frequency property\n",
+ cn->full_name);
+ continue;
+ }
+
+ capacity = ((be32_to_cpup(rate)) >> 20) * cpu_eff->efficiency;
+
+ /* Save min capacity of the system */
+ if (capacity < min_capacity)
+ min_capacity = capacity;
+
+ /* Save max capacity of the system */
+ if (capacity > max_capacity)
+ max_capacity = capacity;
+
+ cpu_capacity(cpu) = capacity;
+ }
+
+ /* If min and max capacities are equal we bypass the update of the
+ * cpu_scale because all CPUs have the same capacity. Otherwise, we
+ * compute a middle_capacity factor that will ensure that the capacity
+ * of an 'average' CPU of the system will be as close as possible to
+ * SCHED_POWER_SCALE, which is the default value, but with the
+ * constraint explained near table_efficiency[].
+ */
+ if (min_capacity == max_capacity)
+ return;
+ else if (4 * max_capacity < (3 * (max_capacity + min_capacity)))
+ middle_capacity = (min_capacity + max_capacity)
+ >> (SCHED_POWER_SHIFT+1);
+ else
+ middle_capacity = ((max_capacity / 3)
+ >> (SCHED_POWER_SHIFT-1)) + 1;
+}
+
+/*
+ * Look for a customed capacity of a CPU in the cpu_topo_data table during the
+ * boot. The update of all CPUs is in O(n^2) for heteregeneous system but the
+ * function returns directly for SMP system.
+ */
+static void update_cpu_power(unsigned int cpu)
+{
+ if (!cpu_capacity(cpu))
+ return;
+
+ set_power_scale(cpu, cpu_capacity(cpu) / middle_capacity);
+
+ pr_info("CPU%u: update cpu_power %lu\n",
+ cpu, arch_scale_freq_power(NULL, cpu));
+}
+
/*
* cpu topology table
*/
@@ -249,6 +390,7 @@ static void update_siblings_masks(unsigned int cpuid)
void store_cpu_topology(unsigned int cpuid)
{
update_siblings_masks(cpuid);
+ update_cpu_power(cpuid);
}
static void __init reset_cpu_topology(void)
@@ -269,6 +411,14 @@ static void __init reset_cpu_topology(void)
}
}
+static void __init reset_cpu_power(void)
+{
+ unsigned int cpu;
+
+ for_each_possible_cpu(cpu)
+ set_power_scale(cpu, SCHED_POWER_SCALE);
+}
+
void __init init_cpu_topology(void)
{
reset_cpu_topology();
@@ -279,4 +429,7 @@ void __init init_cpu_topology(void)
*/
if (parse_dt_topology())
reset_cpu_topology();
+
+ reset_cpu_power();
+ parse_dt_cpu_power();
}
--
1.9.2
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH 4/4] arm64: topology: Provide relative power numbers for cores
2014-04-22 20:21 [PATCH 1/4] arm64: topology: Initialise default topology state immediately Mark Brown
2014-04-22 20:21 ` [PATCH 2/4] arm64: topology: Add support for topology DT bindings Mark Brown
2014-04-22 20:21 ` [PATCH 3/4] arm64: topology: Tell the scheduler about the relative power of cores Mark Brown
@ 2014-04-22 20:21 ` Mark Brown
2014-04-24 14:39 ` [PATCH 1/4] arm64: topology: Initialise default topology state immediately Lorenzo Pieralisi
3 siblings, 0 replies; 7+ messages in thread
From: Mark Brown @ 2014-04-22 20:21 UTC (permalink / raw)
To: linux-arm-kernel
From: Mark Brown <broonie@linaro.org>
Provide performance numbers to the scheduler to help it fill the cores in
the system on big.LITTLE systems. With the current scheduler this may
perform poorly for applications that try to do OpenMP style work over all
cores but should help for more common workloads. The current 32 bit ARM
implementation provides a similar estimate so this helps ensure that
work to improve big.LITTLE systems on ARMv7 systems performs similarly
on ARMv8 systems.
The power numbers are the same as for ARMv7 since it seems that the
expected differential between the big and little cores is very similar on
both ARMv7 and ARMv8. In both ARMv7 and ARMv8 cases the numbers were
based on the published DMIPS numbers.
These numbers are just an initial and basic approximation for use with
the current scheduler, it is likely that both experience with silicon
and ongoing work on improving the scheduler will lead to further tuning
or will tune automatically at runtime and so make the specific choice of
numbers here less critical.
Signed-off-by: Mark Brown <broonie@linaro.org>
---
arch/arm64/kernel/topology.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
index a912f3a7c804..caf2a7cc7673 100644
--- a/arch/arm64/kernel/topology.c
+++ b/arch/arm64/kernel/topology.c
@@ -199,6 +199,8 @@ struct cpu_efficiency {
* use the default SCHED_POWER_SCALE value for cpu_scale.
*/
static const struct cpu_efficiency table_efficiency[] = {
+ { "arm,cortex-a57", 3891 },
+ { "arm,cortex-a53", 2048 },
{ NULL, },
};
--
1.9.2
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH 1/4] arm64: topology: Initialise default topology state immediately
2014-04-22 20:21 [PATCH 1/4] arm64: topology: Initialise default topology state immediately Mark Brown
` (2 preceding siblings ...)
2014-04-22 20:21 ` [PATCH 4/4] arm64: topology: Provide relative power numbers for cores Mark Brown
@ 2014-04-24 14:39 ` Lorenzo Pieralisi
3 siblings, 0 replies; 7+ messages in thread
From: Lorenzo Pieralisi @ 2014-04-24 14:39 UTC (permalink / raw)
To: linux-arm-kernel
On Tue, Apr 22, 2014 at 09:21:15PM +0100, Mark Brown wrote:
> From: Mark Brown <broonie@linaro.org>
>
> As a legacy of the way 32 bit ARM did things the topology code uses a null
> topology map by default and then overwrites it by mapping cores with no
> information to a cluster by themselves later. In order to make it simpler
> to reset things as part of recovering from parse failures in firmware
> information directly set this configuration on init. A core will always be
> its own sibling so there should be no risk of confusion with firmware
> provided information.
>
> Signed-off-by: Mark Brown <broonie@linaro.org>
> ---
> arch/arm64/kernel/topology.c | 8 ++++----
> 1 file changed, 4 insertions(+), 4 deletions(-)
>
> diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
> index 3e06b0be4ec8..ff662b23af5f 100644
> --- a/arch/arm64/kernel/topology.c
> +++ b/arch/arm64/kernel/topology.c
> @@ -43,9 +43,6 @@ static void update_siblings_masks(unsigned int cpuid)
> * reset it to default behaviour
> */
> pr_debug("CPU%u: No topology information configured\n", cpuid);
> - cpuid_topo->core_id = 0;
> - cpumask_set_cpu(cpuid, &cpuid_topo->core_sibling);
> - cpumask_set_cpu(cpuid, &cpuid_topo->thread_sibling);
> return;
> }
>
> @@ -87,9 +84,12 @@ void __init init_cpu_topology(void)
> struct cpu_topology *cpu_topo = &cpu_topology[cpu];
>
> cpu_topo->thread_id = -1;
> - cpu_topo->core_id = -1;
> + cpu_topo->core_id = 0;
> cpu_topo->cluster_id = -1;
> +
> cpumask_clear(&cpu_topo->core_sibling);
> + cpumask_set_cpu(cpu, &cpu_topo->core_sibling);
> cpumask_clear(&cpu_topo->thread_sibling);
> + cpumask_set_cpu(cpu, &cpu_topo->thread_sibling);
> }
> }
Reviewed-by: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
^ permalink raw reply [flat|nested] 7+ messages in thread