sched: introduce compute capacity for CPUs, groups and domains
Subsystems (4)
A message that is not in the archive (sent off-list or not yet received): [email protected]
RFC PATCH 1/3 ARM: (Experimental) Provide Estimated CPU Capacity measure
Bsed upon the CPU Power of a core, computes a capacity measure between 0 and 1024 scaling in line with the frequency using a simple linear scale derived from the maximum frequency reported by CPUFreq.
Scaling CPU Power with frequency and estimated capacity gives an estimate of the amount of potential compute capacity available to a specific core relative to any other in the system.
Change-Id: I8048a23fe5999536b6325a5ec64549dd69f5a865
--- arch/arm/Kconfig | 16 +++ arch/arm/include/asm/topology.h | 7 ++ arch/arm/kernel/topology.c | 216 ++++++++++++++++++++++++++++++++++++- drivers/base/topology.c | 18 ++++ linaro/configs/big-LITTLE-MP.conf | 3 +- 5 files changed, 258 insertions(+), 2 deletions(-)
arch/arm/Kconfig +16 -0
@@ -1624,6 +1624,22 @@ config SCHED_SMT MultiThreading at a cost of slightly increased overhead in some places. If unsure say N here. +config ARCH_SCALE_INVARIANT_CPU_CAPACITY + bool "Scale-Invariant CPU Compute Capacity Recording (EXPERIMENTAL)" + depends on EXPERIMENTAL + depends on CPU_FREQ + help + Provides a new measure of maximum and instantaneous CPU compute + capacity, derived from a table of relative compute performance + for each core type present in the system. The table is an + estimate and specific core performance may be different for + any particular workload. The measure includes the relative + performance and a linear scale of current to maximum frequency + such that at maximum frequency (as expressed in the DTB) the + reported compute capacity will be equal to the estimated + performance from the table. Values range between 0 and 1023 where + 1023 is the highest capacity available in the system. + config HAVE_ARM_SCU bool help
arch/arm/include/asm/topology.h +7 -0
@@ -19,6 +19,13 @@ extern struct cputopo_arm cpu_topology[NR_CPUS];#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) +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY +extern unsigned long arch_get_max_cpu_capacity (int ); +extern unsigned long arch_get_cpu_capacity (int ); + +#define topology_max_cpu_capacity (cpu) (arch_get_max_cpu_capacity(cpu)) +#define topology_cpu_capacity (cpu) (arch_get_cpu_capacity(cpu)) +#endif #define mc_capable () (cpu_topology[0].socket_id != -1)#define smt_capable () (cpu_topology[0].thread_id != -1)
arch/arm/kernel/topology.c +215 -1
237 lines not on this page · raw message
drivers/base/topology.c +18 -0
@@ -43,6 +43,13 @@ static ssize_t show_##name(struct device *dev, \unsigned int cpu = dev->id; \ return sprintf(buf, "%d\n", topology_##name(cpu)); \ } +#define define_id_lu_show_func (name) \ +static ssize_t show_##name(struct device *dev, \ + struct device_attribute *attr, char *buf) \ +{ \ + unsigned int cpu = dev->id; \ + return sprintf(buf, "%lu\n", topology_##name(cpu)); \ +}#if defined(topology_thread_cpumask) || defined(topology_core_cpumask) || \ defined(topology_book_cpumask)
@@ -122,6 +129,13 @@ define_one_ro_named(book_siblings, show_book_cpumask);define_one_ro_named (book_siblings_list, show_book_cpumask_list);#endif +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY +define_id_lu_show_func (max_cpu_capacity); +define_one_ro (max_cpu_capacity); +define_id_lu_show_func (cpu_capacity); +define_one_ro (cpu_capacity); +#endif +static struct attribute *default_attrs[] = { &dev_attr_physical_package_id.attr, &dev_attr_core_id.attr,
@@ -134,6 +148,10 @@ static struct attribute *default_attrs[] = { &dev_attr_book_siblings.attr, &dev_attr_book_siblings_list.attr, #endif +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY + &dev_attr_max_cpu_capacity.attr, + &dev_attr_cpu_capacity.attr, +#endifNULL };
linaro/configs/big-LITTLE-MP.conf +2 -1
@@ -8,6 +8,7 @@ CONFIG_SCHED_HMP=y CONFIG_HMP_FAST_CPU_MASK="" CONFIG_HMP_SLOW_CPU_MASK="" CONFIG_HMP_VARIABLE_SCALE=y -CONFIG_HMP_FREQUENCY_INVARIANT_SCALE=y CONFIG_SCHED_HMP_PRIO_FILTER=y CONFIG_SCHED_HMP_PRIO_FILTER_VAL=5 +CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY=y +
--
1.7.9.5
-- IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you. ���{.n�+�������+%�����ݶ��w��{.n�+����{��G�����{ay�ʇڙ�,j��f���h��������z_�(�階�ݢj"���m������G������?����&���~��iO��z��v�^�m����������?�I�
RFC PATCH 2/3 sched: introduce compute capacity for CPUs, groups and domains
In reply to a message not in the archiveUsing the per-cpu compute capacity exported from topology when CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY is active, place this information alongside cpu_power in the scheduler and combine for the various aggregating entities.
Change-Id: I4984c335bcdc128680e7459b3f86bb05e04593cc
--- include/linux/sched.h | 7 +++++ include/trace/events/sched.h | 24 +++++++++++++++ kernel/sched/core.c | 2 ++ kernel/sched/debug.c | 3 ++ kernel/sched/fair.c | 69 ++++++++++++++++++++++++++++++++++++++---- kernel/sched/sched.h | 4 +++ 6 files changed, 103 insertions(+), 6 deletions(-)
include/linux/sched.h +7 -0
@@ -863,6 +863,13 @@ struct sched_group_power {unsigned int power, power_orig;unsigned long next_update;/* +* Compute capacity of this group, where each CPU has a compute +* capacity expressed as a value [0..SCHED_POWER_SCALE] against +* the most powerful CPU in the system of capacity SCHED_POWER_SCALE. +*/ +unsigned int compute_capacity; +unsigned int max_compute_capacity; +/* * Number of busy cpus in this group. */ atomic_t nr_busy_cpus;
include/trace/events/sched.h +24 -0
@@ -985,6 +985,30 @@ TRACE_EVENT(sched_fsi, );/* +* Extra debug trace points +*/ +TRACE_EVENT (sched_upd_cap, + + TP_PROTO(int dst_cpu, unsigned long curr, unsigned long max ), + +TP_ARGS (dst_cpu, curr, max ), + +TP_STRUCT__entry ( + __field(int, dst_cpu) + __field(unsigned long, curr) + __field(unsigned long, max) + ), + +TP_fast_assign ( + __entry->dst_cpu = dst_cpu; + __entry->curr = curr; + __entry->max = max; + ), + +TP_printk ("cpu=%d curr=%lu max=%lu" , + __entry->dst_cpu, __entry->curr, __entry->max) +); +/* * Tracepoint for showing priority inheritance modifying a tasks * priority. */
kernel/sched/core.c +2 -0
@@ -6940,6 +6940,8 @@ void __init sched_init(void) rq->sd =NULL ; rq->rd =NULL ; rq->cpu_power =SCHED_POWER_SCALE ; + rq->curr_compute_capacity =SCHED_POWER_SCALE ; + rq->max_compute_capacity =SCHED_POWER_SCALE ; rq->post_schedule =0 ; rq->active_balance =0 ; rq->next_balance = jiffies;
kernel/sched/debug.c +3 -0
@@ -290,6 +290,9 @@ do { \#define PN (x) \ SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rq->x)) +P (cpu_power); +P (curr_compute_capacity); +P (max_compute_capacity);P (nr_running);SEQ_printf (m," .%-30s: %lu\n" ,"load" , rq->load.weight);
kernel/sched/fair.c +63 -6
156 lines not on this page · raw message
kernel/sched/sched.h +4 -0
@@ -412,6 +412,10 @@ struct rq {unsigned long cpu_power; +/* CPU compute capacity estimation */ +unsigned long max_compute_capacity; +unsigned long curr_compute_capacity; +unsigned char idle_balance;/* For active balancing */ int post_schedule;
Signature · 1 line
1.7.9.5
RFC PATCH 3/3 sched: Scale load contribution by CPU Capacity
In reply to a message not in the archiveModulate the tracked load of a task using the measure of current and maximum compute capacity for the core it is executing on.
Change-Id: If6aea806e631f2313fd925c8902260a522663dbd
Conflicts:
kernel/sched/fair.c
--- kernel/sched/fair.c | 51 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 43 insertions(+), 8 deletions(-)
kernel/sched/fair.c +43 -8
@@ -1319,11 +1319,15 @@ static inline void update_cpu_capacity(int cpu) static __always_inline int __update_entity_runnable_avg(u64 now,struct sched_avg *sa,int runnable, -int running) +int running, +int cpu) {u64 delta, periods;u32 runnable_contrib;int delta_w, decayed =0 ; +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY +u32 curr_scale =1 <<SCHED_ARCH_SCALE_POWER_SHIFT ; +#endif /* CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY */ delta = now - sa->last_runnable_update;/*
@@ -1344,6 +1348,12 @@ static __always_inline int __update_entity_runnable_avg(u64 now,return 0 ; sa->last_runnable_update = now; +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY +update_cpu_capacity (cpu); + curr_scale = (compute_capacity_of (cpu) <<SCHED_ARCH_SCALE_POWER_SHIFT ) + / (max_compute_capacity_of (cpu)+1 ); +#endif +/* delta_w is the amount already accumulated against our next period */ delta_w = sa->runnable_avg_period %1024 ;if (delta + delta_w >=1024 ) {
@@ -1356,13 +1366,17 @@ static __always_inline int __update_entity_runnable_avg(u64 now,* period and accrue it. */ delta_w =1024 - delta_w; + sa->runnable_avg_period += delta_w; + delta -= delta_w; +/* scale runnable time if necessary */ +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY + delta_w = (delta_w * curr_scale) + >>SCHED_ARCH_SCALE_POWER_SHIFT ; +#endif if (runnable) sa->runnable_avg_sum += delta_w;if (running) sa->usage_avg_sum += delta_w; - sa->runnable_avg_period += delta_w; - - delta -= delta_w;/* Figure out how many additional periods this update spans */ periods = delta /1024 ;
@@ -1376,19 +1390,31 @@ static __always_inline int __update_entity_runnable_avg(u64 now,/* Efficiently calculate \sum (1..n_period) 1024*y^i */ runnable_contrib =__compute_runnable_contrib (periods); + sa->runnable_avg_period += runnable_contrib; +/* Apply load scaling if necessary. +* Note that multiplying the whole series is same as +* multiplying all terms +*/ +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY + runnable_contrib = (runnable_contrib * curr_scale) + >>SCHED_ARCH_SCALE_POWER_SHIFT ; +#endif if (runnable) sa->runnable_avg_sum += runnable_contrib;if (running) sa->usage_avg_sum += runnable_contrib; - sa->runnable_avg_period += runnable_contrib; }/* Remainder of delta accrued against u_0` */ + sa->runnable_avg_period += delta; +/* scale if necessary */ +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY + delta = ((delta * curr_scale) >>SCHED_ARCH_SCALE_POWER_SHIFT ); +#endif if (runnable) sa->runnable_avg_sum += delta;if (running) sa->usage_avg_sum += delta; - sa->runnable_avg_period += delta;return decayed; }
@@ -1551,7 +1577,11 @@ static inline void update_entity_load_avg(struct sched_entity *se,struct cfs_rq *cfs_rq =cfs_rq_of (se);long contrib_delta;u64 now; +int cpu =-1 ;/* not used in normal case */ +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY + cpu = cfs_rq->rq->cpu; +#endif /* * For a group entity we need to use their owned cfs_rq_clock_task() in * case they are the parent of a throttled hierarchy.
@@ -1562,7 +1592,7 @@ static inline void update_entity_load_avg(struct sched_entity *se, now =cfs_rq_clock_task (group_cfs_rq (se));if (!__update_entity_runnable_avg (now, &se->avg, se->on_rq, - cfs_rq->curr == se)) + cfs_rq->curr == se, cpu))return ; contrib_delta =__update_entity_load_avg_contrib (se);
@@ -1607,8 +1637,13 @@ static void update_cfs_rq_blocked_load(struct cfs_rq *cfs_rq, int force_update)static inline void update_rq_runnable_avg (struct rq *rq,int runnable) {u32 contrib; +int cpu =-1 ;/* not used in normal case */ + +#ifdef CONFIG_ARCH_SCALE_INVARIANT_CPU_CAPACITY + cpu = rq->cpu; +#endif __update_entity_runnable_avg (rq->clock_task, &rq->avg, runnable, - runnable); + runnable, cpu);__update_tg_runnable_avg (&rq->avg, &rq->cfs); contrib = rq->avg.runnable_avg_sum *scale_load_down (1024 ); contrib /= (rq->avg.runnable_avg_period +1 );
Signature · 1 line
1.7.9.5