arm64: topology: Implement basic CPU topology support
PATCH 1/4 arm64: topology: Implement basic CPU topology support
From: Mark Brown <[email protected]>
Add basic CPU topology support to arm64, based on the existing pre-v8 code and some work done by Mark Hambleton. This patch does not implement any topology discovery support since that should be based on information from firmware, it merely implements the scaffolding for integration of topology support in the architecture.
The goal is to separate the architecture hookup for providing topology information from the DT parsing in order to ease review and avoid blocking the architecture code (which will be built on by other work) with the DT code review by providing something simple and basic.
A following patch will implement support for parsing the DT topology bindings for ARM, similar patches will be needed for ACPI.
--- arch/arm64/Kconfig | 24 +++++++++++ arch/arm64/include/asm/topology.h | 39 +++++++++++++++++ arch/arm64/kernel/Makefile | 1 + arch/arm64/kernel/smp.c | 11 +++++ arch/arm64/kernel/topology.c | 91 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 166 insertions(+) create mode 100644 arch/arm64/include/asm/topology.h create mode 100644 arch/arm64/kernel/topology.c
arch/arm64/Kconfig +24 -0
@@ -164,6 +164,30 @@ config SMP If you don't know what to do here, say N. +config CPU_TOPOLOGY + bool "Support CPU topology definition" + depends on SMP + default y + help + Support CPU topology definition, based on configuration + provided by the firmware. + +config SCHED_MC + bool "Multi-core scheduler support" + depends on CPU_TOPOLOGY + help + Multi-core scheduler support improves the CPU scheduler's decision + making when dealing with multi-core CPU chips at a cost of slightly + increased overhead in some places. If unsure say N here. + +config SCHED_SMT + bool "SMT scheduler support" + depends on CPU_TOPOLOGY + help + Improves the CPU scheduler's decision making when dealing with + MultiThreading at a cost of slightly increased overhead in some + places. If unsure say N here. + config NR_CPUS int "Maximum number of CPUs (2-32)" range 2 32
arch/arm64/include/asm/topology.h new file +39 -0
@@ -0,0 +1,39 @@ +#ifndef __ASM_TOPOLOGY_H +#define __ASM_TOPOLOGY_H + +#ifdef CONFIG_CPU_TOPOLOGY + +#include <linux/cpumask.h> + +struct cpu_topology { +int thread_id; +int core_id; +int cluster_id; +cpumask_t thread_sibling; +cpumask_t core_sibling; +}; + +extern struct cpu_topology cpu_topology[NR_CPUS ]; + +#define topology_physical_package_id (cpu) (cpu_topology[cpu].cluster_id) +#define topology_core_id (cpu) (cpu_topology[cpu].core_id) +#define topology_core_cpumask (cpu) (&cpu_topology[cpu].core_sibling) +#define topology_thread_cpumask (cpu) (&cpu_topology[cpu].thread_sibling) + +#define mc_capable () (cpu_topology[0].cluster_id != -1) +#define smt_capable () (cpu_topology[0].thread_id != -1) + +void init_cpu_topology (void ); +void store_cpu_topology (unsigned int cpuid); +const struct cpumask *cpu_coregroup_mask (int cpu); + +#else + +static inline void init_cpu_topology (void ) { } +static inline void store_cpu_topology (unsigned int cpuid) { } + +#endif + +#include <asm-generic/topology.h> + +#endif /* _ASM_ARM_TOPOLOGY_H */
arch/arm64/kernel/Makefile +1 -0
@@ -20,6 +20,7 @@ arm64-obj-$(CONFIG_HAVE_HW_BREAKPOINT)+= hw_breakpoint.o arm64-obj-$(CONFIG_EARLY_PRINTK) += early_printk.o arm64-obj-$(CONFIG_ARM64_CPU_SUSPEND) += sleep.o suspend.o arm64-obj-$(CONFIG_JUMP_LABEL) += jump_label.o +arm64-obj-$(CONFIG_CPU_TOPOLOGY) += topology.o obj-y += $(arm64-obj-y) vdso/ obj-m += $(arm64-obj-m)
arch/arm64/kernel/smp.c +11 -0
@@ -114,6 +114,11 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle)return ret; } +static void smp_store_cpu_info (unsigned int cpuid) +{ +store_cpu_topology (cpuid); +} +/* * This is the secondary CPU boot entry. We're using this CPUs * idle thread stack, but a set of temporary page tables.
@@ -152,6 +157,8 @@ asmlinkage void secondary_start_kernel(void)*/ notify_cpu_starting (cpu); +smp_store_cpu_info (cpu); +/* * OK, now it's safe to let the boot CPU continue. Wait for * the CPU migration code to notice that the CPU is online
@@ -390,6 +397,10 @@ void __init smp_prepare_cpus(unsigned int max_cpus)int err;unsigned int cpu, ncores =num_possible_cpus (); +init_cpu_topology (); + +smp_store_cpu_info (smp_processor_id ()); +/* * are we trying to boot more cores than exist? */
arch/arm64/kernel/topology.c new file +91 -0
91 lines not on this page · raw message
Signature · 1 line
1.9.0.rc3
PATCH 2/4 arm64: topology: Add support for topology DT bindings
From: Mark Brown <[email protected]>
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.
--- arch/arm64/kernel/topology.c | 143 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+)
arch/arm64/kernel/topology.c +143 -0
@@ -17,10 +17,150 @@#include <linux/percpu.h> #include <linux/node.h> #include <linux/nodemask.h> +#include <linux/of.h> #include <linux/sched.h> #include <asm/topology.h> +#ifdef CONFIG_OF +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) +return cpu; + } + +pr_crit ("Unable to find CPU node for %s\n" , cpu_node->full_name); +return -1 ; +} + +static void __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); + } + } + 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 ; + } + + 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); + } +} + +static void __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 __initdata cluster_id; +int core_id =0 ; +int i; + +/* +* 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) { +parse_cluster (c, depth +1 ); + leaf = false; + } + 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); + +if (leaf) +parse_core (c, cluster_id, core_id++); +else +pr_err ("%s: Non-leaf cluster with core %s\n" , + cluster->full_name, name); + } + i++; + }while (c); + +if (leaf && !has_cores) +pr_warn ("%s: empty cluster\n" , cluster->full_name); + +if (leaf) + cluster_id++; +} + +static void __init parse_dt_topology (void ) +{ +struct device_node *cn; + + cn =of_find_node_by_path ("/cpus" ); +if (!cn) { +pr_err ("No CPU information found in DT\n" ); +return ; + } + +/* +* When topology is provided cpu-map is essentially a root +* cluster with restricted subnodes. +*/ + cn =of_find_node_by_name (cn,"cpu-map" ); +if (!cn) +return ; +parse_cluster (cn,0 ); +} + +#else +static inline void parse_dt_topology (void ) {} +#endif +/* * cpu topology table */
@@ -87,5 +227,8 @@ void __init init_cpu_topology(void)cpumask_clear (&cpu_topo->core_sibling);cpumask_clear (&cpu_topo->thread_sibling); } + +parse_dt_topology (); +smp_wmb (); }
Signature · 1 line
1.9.0.rc3
PATCH 3/4 arm64: topology: Tell the scheduler about the relative power of cores
In reply to Mark BrownFrom: Mark Brown <[email protected]>
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.
--- arch/arm64/kernel/topology.c | 142 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+)
arch/arm64/kernel/topology.c +142 -0
@@ -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; +} +#ifdef CONFIG_OF static int __init get_cpu_for_node (struct device_node *node) {
@@ -137,9 +161,49 @@ static void __init parse_cluster(struct device_node *cluster, int depth) cluster_id++; } +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 void __init parse_dt_topology (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 ); cn =of_find_node_by_path ("/cpus" );if (!cn) {
@@ -155,10 +219,84 @@ static void __init parse_dt_topology(void)if (!cn)return ;parse_cluster (cn,0 ); + +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)); }#else static inline void parse_dt_topology (void ) {} +static inline void update_cpu_power (unsigned int cpuid) {}#endif /*
@@ -207,6 +345,8 @@ void store_cpu_topology(unsigned int cpuid)pr_info ("CPU%u: No topology information configured\n" , cpuid); elseupdate_siblings_masks (cpuid ); + +update_cpu_power (cpuid); }/*
@@ -226,6 +366,8 @@ void __init init_cpu_topology(void) cpu_topo->cluster_id =-1 ;cpumask_clear (&cpu_topo->core_sibling);cpumask_clear (&cpu_topo->thread_sibling); + +set_power_scale (cpu,SCHED_POWER_SCALE ); }parse_dt_topology ();
Signature · 1 line
1.9.0.rc3
PATCH 4/4 arm64: topology: Provide relative power numbers for cores
In reply to Mark BrownFrom: Mark Brown <[email protected]>
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.
--- arch/arm64/kernel/topology.c | 2 ++ 1 file changed, 2 insertions(+)
arch/arm64/kernel/topology.c +2 -0
@@ -177,6 +177,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 , }, };
Signature · 1 line
1.9.0.rc3
Catalin Marinas
maintainerPATCH 1/4 arm64: topology: Implement basic CPU topology support
In reply to Mark BrownQuoted 14 lines · Mark Brown
arch/arm64/kernel/topology.c new file +14
-0+static void update_siblings_masks (unsigned int cpuid) +{ +struct cpu_topology *cpu_topo, *cpuid_topo = &cpu_topology[cpuid]; +int cpu; + +/* update core and thread sibling masks */ +for_each_possible_cpu (cpu) { + cpu_topo = &cpu_topology[cpu]; + +if (cpuid_topo->cluster_id != cpu_topo->cluster_id) +continue ; + +cpumask_set_cpu (cpuid, &cpu_topo->core_sibling); +if (cpu != cpuid)
arch/arm64/kernel/topology.c line 58
Quoted 10 lines
arch/arm64/kernel/topology.c new file +10
-0+cpumask_set_cpu (cpu, &cpuid_topo->core_sibling); + +if (cpuid_topo->core_id != cpu_topo->core_id) +continue ; + +cpumask_set_cpu (cpuid, &cpu_topo->thread_sibling); +if (cpu != cpuid) +cpumask_set_cpu (cpu, &cpuid_topo->thread_sibling); + } +smp_wmb ();
I now noticed there are a couple of smp_wmb() calls in this patch. What are they for?
Signature · 1 line
Catalin
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 9 lines · Catalin Marinas
arch/arm64/kernel/topology.c line 58
Quoted 4 lines · Mark Brown
arch/arm64/kernel/topology.c new file +4
-0+if (cpu != cpuid) +cpumask_set_cpu (cpu, &cpuid_topo->thread_sibling); + } +smp_wmb ();I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?
To be honest I mostly cargo culted them from the ARM implementation; I
did look a bit but didn't fully dig into it - it seemed they were
required to ensure that the updates for the new CPU are visible over all
CPUs. Vincent?
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140210/fc8ec600/attachment-0001.sig>
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 8 lines · Mark Brown
Quoted 6 lines · Catalin Marinas
Quoted 4 lines · Mark Brown
arch/arm64/kernel/topology.c new file +4
-0+if (cpu != cpuid) +cpumask_set_cpu (cpu, &cpuid_topo->thread_sibling); + } +smp_wmb ();
Quoted 7 lines
Quoted 2 lines
I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Yes that's it. we must ensure that updates are made visible to other CPUs
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 12 lines · Vincent Guittot
Quoted 11 lines · Mark Brown
Quoted 9 lines · Catalin Marinas
arch/arm64/kernel/topology.c line 58
Quoted 4 lines · Mark Brown
arch/arm64/kernel/topology.c new file +4
-0+if (cpu != cpuid) +cpumask_set_cpu (cpu, &cpuid_topo->thread_sibling); + } +smp_wmb ();I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?
Quoted 6 lines
Quoted 4 lines
To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Yes that's it. we must ensure that updates are made visible to other CPUs
In relation to what? The smp_* barriers ensure ordering of observability between a number of independent accesses, so you must be ensuring ordering against something else. Also, you need to guarantee ordering on the read-side too -- how is this achieved? I can't see any smp_rmb calls from a quick grep, so I assume you're making use of address dependencies?
/confused
Will
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 18 lines · Will Deacon
Quoted 17 lines · Vincent Guittot
Quoted 15 lines · Mark Brown
Quoted 9 lines · Catalin Marinas
arch/arm64/kernel/topology.c line 58
Quoted 4 lines · Mark Brown
arch/arm64/kernel/topology.c new file +4
-0+if (cpu != cpuid) +cpumask_set_cpu (cpu, &cpuid_topo->thread_sibling); + } +smp_wmb ();I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Quoted 7 lines
Quoted 1 line
Yes that's it. we must ensure that updates are made visible to other CPUs
In relation to what? The smp_* barriers ensure ordering of observability between a number of independent accesses, so you must be ensuring ordering against something else. Also, you need to guarantee ordering on the read-side too -- how is this achieved? I can't see any
smp_rmbcalls from a quick grep, so I assume you're making use of address dependencies?
The boot sequence ensures the rmb
Vincent
Quoted 4 lines
/confused
Will
Catalin Marinas
maintainerPATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 21 lines · Vincent Guittot
Quoted 20 lines · Will Deacon
Quoted 18 lines · Vincent Guittot
Quoted 8 lines · Mark Brown
Quoted 6 lines · Catalin Marinas
Quoted 4 lines · Mark Brown
arch/arm64/kernel/topology.c new file +4
-0+if (cpu != cpuid) +cpumask_set_cpu (cpu, &cpuid_topo->thread_sibling); + } +smp_wmb ();Quoted 7 lines
Quoted 2 lines
I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Yes that's it. we must ensure that updates are made visible to other CPUs
Quoted 7 lines
Quoted 5 lines
In relation to what? The smp_* barriers ensure ordering of observability between a number of independent accesses, so you must be ensuring ordering against something else. Also, you need to guarantee ordering on the read-side too -- how is this achieved? I can't see any
smp_rmbcalls from a quick grep, so I assume you're making use of address dependencies?The boot sequence ensures the rmb
As Will said, smp_*mb() do not ensure absolute visibility, only relative to subsequent memory accesses on the same processor. So just placing a barrier at the end of a function does not mean much, it only shows half of the problem it is trying to solve.
How are the secondary CPUs using this information? AFAICT, secondaries call smp_store_cpu_info() which also go through each CPU in update_siblings_mask(). Is there any race here that smp_wmb() is trying to solve?
I guess for secondaries you could move the barrier just before set_cpu_online(), this way it is clear that we want any previous writes to become visible when this CPU is marked online. For the primary, any memory writes should become visible before the CPU is started. One synchronisation point is the pen release, depending on the smp_ops. I think that's already covered by code like arch/arm/mach-*/platsmp.c.
So my proposal is to remove the smp_wmb() from topology.c and add it where it is relevant as described above. If we have some race in topology.c (like for example we may later decide to start more secondaries at the same time), it needs to be solved using spinlocks.
Signature · 1 line
Catalin
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 28 lines · Catalin Marinas
Quoted 27 lines · Vincent Guittot
Quoted 25 lines · Will Deacon
Quoted 12 lines · Vincent Guittot
Quoted 11 lines · Mark Brown
Quoted 9 lines · Catalin Marinas
Review
Quoted 4 lines · Mark Brown
(quoted diff) +4
-0+ if (cpu != cpuid) + cpumask_set_cpu(cpu, &cpuid_topo->thread_sibling); + } + smp_wmb();I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?Quoted 6 lines
Quoted 4 lines
To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Yes that's it. we must ensure that updates are made visible to other CPUs
In relation to what? The smp_* barriers ensure ordering of observability between a number of independent accesses, so you must be ensuring ordering against something else. Also, you need to guarantee ordering on the read-side too -- how is this achieved? I can't see any
smp_rmbcalls from a quick grep, so I assume you're making use of address dependencies?
Quoted 6 lines
Quoted 1 line
The boot sequence ensures the rmb
As Will said, smp_*mb() do not ensure absolute visibility, only relative to subsequent memory accesses on the same processor. So just placing a barrier at the end of a function does not mean much, it only shows half of the problem it is trying to solve.
OK, that's probably the shortcut that has been made, we want to drain the write buffer to make modification available to other cpus and I though smp_wmb and the associated mb(ishst) was there for that purpose.
Vincent
Quoted 20 lines
How are the secondary CPUs using this information? AFAICT, secondaries call
smp_store_cpu_info()which also go through each CPU inupdate_siblings_mask(). Is there any race here thatsmp_wmb()is trying to solve?I guess for secondaries you could move the barrier just before
set_cpu_online(), this way it is clear that we want any previous writes to become visible when this CPU is marked online. For the primary, any memory writes should become visible before the CPU is started. One synchronisation point is the pen release, depending on thesmp_ops. I think that's already covered by code likearch/arm/mach-*/platsmp.c.So my proposal is to remove the
smp_wmb()fromtopology.cand add it where it is relevant as described above. If we have some race intopology.c(like for example we may later decide to start more secondaries at the same time), it needs to be solved using spinlocks.--
Catalin
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 11 lines · Vincent Guittot
Quoted 4 lines · Catalin Marinas
As Will said, smp_*mb() do not ensure absolute visibility, only relative to subsequent memory accesses on the same processor. So just placing a barrier at the end of a function does not mean much, it only shows half of the problem it is trying to solve.
OK, that's probably the shortcut that has been made, we want to drain the write buffer to make modification available to other cpus and I though
smp_wmband the associated mb(ishst) was there for that purpose.
It does also explain where I got to trying to figure out what exactly the mechanism was!
Quoted 4 lines
Quoted 4 lines
So my proposal is to remove the
smp_wmb()fromtopology.cand add it where it is relevant as described above. If we have some race intopology.c(like for example we may later decide to start more secondaries at the same time), it needs to be solved using spinlocks.
I'll just repost a version dropping them from the topology series and
separately add the barriers elsewhere. The 32 bit ARM implementation
probably ought to be fixed as well.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140211/af5fc293/attachment-0001.sig>
PATCH 1/4 arm64: topology: Implement basic CPU topology support
In reply to Catalin MarinasQuoted 28 lines · Catalin Marinas
Quoted 27 lines · Vincent Guittot
Quoted 25 lines · Will Deacon
Quoted 12 lines · Vincent Guittot
Quoted 11 lines · Mark Brown
Quoted 9 lines · Catalin Marinas
Review
Quoted 4 lines · Mark Brown
(quoted diff) +4
-0+ if (cpu != cpuid) + cpumask_set_cpu(cpu, &cpuid_topo->thread_sibling); + } + smp_wmb();I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?Quoted 6 lines
Quoted 4 lines
To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Yes that's it. we must ensure that updates are made visible to other CPUs
In relation to what? The smp_* barriers ensure ordering of observability between a number of independent accesses, so you must be ensuring ordering against something else. Also, you need to guarantee ordering on the read-side too -- how is this achieved? I can't see any
smp_rmbcalls from a quick grep, so I assume you're making use of address dependencies?
Quoted 4 lines
Quoted 1 line
The boot sequence ensures the rmb
As Will said, smp_*mb() do not ensure absolute visibility, only relative to subsequent memory accesses on the same processor. So just placing a
It's my time to be a bit confused, if smp_*mb() do not ensure absolute visibility on other CPUs, how can we ensure that ?
Quoted 7 lines
barrier at the end of a function does not mean much, it only shows half of the problem it is trying to solve.
How are the secondary CPUs using this information? AFAICT, secondaries call
smp_store_cpu_info()which also go through each CPU inupdate_siblings_mask(). Is there any race here thatsmp_wmb()is trying to solve?
The fields will be used to construct topology so we must ensure their visibility
Vincent
Quoted 15 lines
I guess for secondaries you could move the barrier just before
set_cpu_online(), this way it is clear that we want any previous writes to become visible when this CPU is marked online. For the primary, any memory writes should become visible before the CPU is started. One synchronisation point is the pen release, depending on thesmp_ops. I think that's already covered by code likearch/arm/mach-*/platsmp.c.So my proposal is to remove the
smp_wmb()fromtopology.cand add it where it is relevant as described above. If we have some race intopology.c(like for example we may later decide to start more secondaries at the same time), it needs to be solved using spinlocks.--
Catalin
Catalin Marinas
maintainerPATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 29 lines · Vincent Guittot
Quoted 28 lines · Catalin Marinas
Quoted 27 lines · Vincent Guittot
Quoted 25 lines · Will Deacon
Quoted 12 lines · Vincent Guittot
Quoted 11 lines · Mark Brown
Quoted 9 lines · Catalin Marinas
Review
Quoted 4 lines · Mark Brown
(quoted diff) +4
-0+ if (cpu != cpuid) + cpumask_set_cpu(cpu, &cpuid_topo->thread_sibling); + } + smp_wmb();I now noticed there are a couple of
smp_wmb()calls in this patch. What are they for?Quoted 6 lines
Quoted 4 lines
To be honest I mostly cargo culted them from the ARM implementation; I did look a bit but didn't fully dig into it - it seemed they were required to ensure that the updates for the new CPU are visible over all CPUs. Vincent?
Yes that's it. we must ensure that updates are made visible to other CPUs
In relation to what? The smp_* barriers ensure ordering of observability between a number of independent accesses, so you must be ensuring ordering against something else. Also, you need to guarantee ordering on the read-side too -- how is this achieved? I can't see any
smp_rmbcalls from a quick grep, so I assume you're making use of address dependencies?
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
The boot sequence ensures the rmb
As Will said, smp_*mb() do not ensure absolute visibility, only relative to subsequent memory accesses on the same processor. So just placing a
It's my time to be a bit confused, if smp_*mb() do not ensure absolute visibility on other CPUs, how can we ensure that ?
smb_wmb()/smb_rmb() do not provide any waiting, they are not synchronisation primitives. You have to use spinlocks or some other polling (and of course, barriers for relative ordering of memory reads/writes).
Quoted 10 lines
Quoted 7 lines
barrier at the end of a function does not mean much, it only shows half of the problem it is trying to solve.
How are the secondary CPUs using this information? AFAICT, secondaries call
smp_store_cpu_info()which also go through each CPU inupdate_siblings_mask(). Is there any race here thatsmp_wmb()is trying to solve?The fields will be used to construct topology so we must ensure their visibility
I wonder whether you need spinlocks around the topology updating code.
Signature · 1 line
Catalin
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 6 lines · Catalin Marinas
Quoted 2 lines · Vincent Guittot
The fields will be used to construct topology so we must ensure their visibility
I wonder whether you need spinlocks around the topology updating code.
It certainly feels a lot safer to have them; if we can't convince
ourselves that the code is safe without them then there's very little
cost in having them so we may as well err on the side of doing that -
does that seem reasonable?
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140212/a4dd9428/attachment.sig>
PATCH 1/4 arm64: topology: Implement basic CPU topology support
In reply to Mark BrownOn Mon, Feb 10, 2014 at 01:02:01PM +0000, Mark Brown wrote:
[...]
arch/arm64/kernel/topology.c line 69
Quoted 9 lines
arch/arm64/kernel/topology.c new file +9
-0+void store_cpu_topology (unsigned int cpuid) +{ +struct cpu_topology *cpuid_topo = &cpu_topology[cpuid]; + +/* DT should have been parsed by the time we get here */ +if (cpuid_topo->core_id ==-1 ) +pr_info ("CPU%u: No topology information configured\n" , cpuid); +else +update_siblings_masks (cpuid);
If the DT does not contain a proper topology the scheduler seem to go for a toss. I tried to track it down and it seems it expects topology cpumasks to be initialized regardless (eg to possible mask), they cannot be left empty.
Either update_siblings_masks is called regardless or possible mask must be copied to the topology masks.
I will have a thorough look to check if the scheduler has a fall-back mechanism.
On top of that, the pr_info message is quite annoying and should be probably downgraded or removed altogether.
Furthermore leaving core_id as -1 should be fine, but I have to have a proper look into the scheduler topology code to countercheck that.
Lorenzo
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 3 lines · Lorenzo Pieralisi
If the DT does not contain a proper topology the scheduler seem to go for a toss. I tried to track it down and it seems it expects topology cpumasks to be initialized regardless (eg to possible mask), they cannot be left empty.
Could you be more specific please? I didn't notice anything particular in my testing but then the fact that it's a model does obscure a lot of things.
Quoted 2 lines
On top of that, the
pr_infomessage is quite annoying and should be probably downgraded or removed altogether.
This was deliberate - since we are not willing to use the MPIDR
information to discover the topology we need to get the information into
the DT bindings in order to discover it. Even in a SMP system there is
a difference in how closely attached the cores are so it seems like we
should be expecting a description of the topology.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140222/c5be7caa/attachment.sig>
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 9 lines · Mark Brown
Quoted 3 lines · Lorenzo Pieralisi
If the DT does not contain a proper topology the scheduler seem to go for a toss. I tried to track it down and it seems it expects topology cpumasks to be initialized regardless (eg to possible mask), they cannot be left empty.
Could you be more specific please? I didn't notice anything particular in my testing but then the fact that it's a model does obscure a lot of things.
I will send you a backtrace, config file, commit.
Problem is hit when CONFIG_SCHED_SMT is on and there is no cpu-map in the dts.
What's a model ? And if you mean the processor model, what can it possibly obscure as long as this patch is concerned ?
Quoted 8 lines
Quoted 2 lines
On top of that, the
pr_infomessage is quite annoying and should be probably downgraded or removed altogether.This was deliberate - since we are not willing to use the MPIDR information to discover the topology we need to get the information into the DT bindings in order to discover it. Even in a SMP system there is a difference in how closely attached the cores are so it seems like we should be expecting a description of the topology.
We have to make a decision. Either we rely on MPIDR_EL1 as a fallback or we barf on missing topology nodes (or we just set-up a flat topology if the cpu-map is missing and do not log anything).
Thanks,
Lorenzo
PATCH 1/4 arm64: topology: Implement basic CPU topology support
Quoted 7 lines · Lorenzo Pieralisi
Quoted 5 lines · Mark Brown
Quoted 3 lines · Lorenzo Pieralisi
If the DT does not contain a proper topology the scheduler seem to go for a toss. I tried to track it down and it seems it expects topology cpumasks to be initialized regardless (eg to possible mask), they cannot be left empty.
Quoted 8 lines
Quoted 3 lines
Could you be more specific please? I didn't notice anything particular in my testing but then the fact that it's a model does obscure a lot of things.
I will send you a backtrace, config file, commit.
Problem is hit when
CONFIG_SCHED_SMTis on and there is no cpu-map in the dts.
Interesting... I did test this incrementally during development but didn't see any issues, though as there have been many stylistic updates so I have to confess it's probably been a while since I ran that test, I'll take a look when I have a stable enough network connection to run the models (I'm on a Shinkansen at the minute so my connection keeps dropping out).
Quoted 2 lines
What's a model ? And if you mean the processor model, what can it possibly obscure as long as this patch is concerned ?
A fast or foundation model. Your only description was "went for a toss" so I had no idea what the problem was, I was guessing that this was some sort of issue with performance like only using one core or something. If it's a crash then using the models won't make a difference but for performance issues the emulation means it's not always apparent when using the system if the kernel is performing poorly or if the emulation is just slow.
Quoted 9 lines
Quoted 8 lines
Quoted 2 lines
On top of that, the
pr_infomessage is quite annoying and should be probably downgraded or removed altogether.This was deliberate - since we are not willing to use the MPIDR information to discover the topology we need to get the information into the DT bindings in order to discover it. Even in a SMP system there is a difference in how closely attached the cores are so it seems like we should be expecting a description of the topology.
Quoted 3 lines
We have to make a decision. Either we rely on
MPIDR_EL1as a fallback or we barf on missing topology nodes (or we just set-up a flat topology if the cpu-map is missing and do not log anything).
Indeed. My personal preference would be that we fall back to MPIDR if
we don't have topology information from the firmware (since it's always
possible that the silicon does the right thing) or failing that we
insist on topology information from the firmware. Once systems are out
in the wild it's potentially painful to get the data added to DTs so
pushing for information in case we need it in the future seems like the
safest approach in cases like this where it's not going to be too much
work to provide.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140223/6988707f/attachment-0001.sig>