arm64: topology: Tell the scheduler about the relative power of cores (e86a290d) · Commits · e / devices / android_kernel_xiaomi_markw

arch/arm64/kernel/topology.c

+153 −0

Original line number	Diff line number	Diff line
		@@ -19,10 +19,34 @@
		#include <linux/nodemask.h>
		#include <linux/of.h>
		#include <linux/sched.h>
		#include <linux/slab.h>

		#include <asm/cputype.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;
		@@ -161,6 +185,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 at 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;
		@@ -200,6 +256,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
		*/
		@@ -269,6 +410,7 @@ void store_cpu_topology(unsigned int cpuid)

		topology_populated:
		update_siblings_masks(cpuid);
		update_cpu_power(cpuid);
		}

		static void __init reset_cpu_topology(void)
		@@ -289,6 +431,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();
		@@ -299,4 +449,7 @@ void __init init_cpu_topology(void)
		*/
		if (parse_dt_topology())
		reset_cpu_topology();

		reset_cpu_power();
		parse_dt_cpu_power();
		}