Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
| 2 | #ifndef _LINUX_ENERGY_MODEL_H |
| 3 | #define _LINUX_ENERGY_MODEL_H |
| 4 | #include <linux/cpumask.h> |
Lukasz Luba | 7d9895c | 2020-05-27 10:58:48 +0100 | [diff] [blame] | 5 | #include <linux/device.h> |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 6 | #include <linux/jump_label.h> |
| 7 | #include <linux/kobject.h> |
| 8 | #include <linux/rcupdate.h> |
| 9 | #include <linux/sched/cpufreq.h> |
| 10 | #include <linux/sched/topology.h> |
| 11 | #include <linux/types.h> |
| 12 | |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 13 | /** |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 14 | * em_perf_state - Performance state of a performance domain |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 15 | * @frequency: The frequency in KHz, for consistency with CPUFreq |
| 16 | * @power: The power consumed at this level, in milli-watts (by 1 CPU or |
| 17 | by a registered device). It can be a total power: static and |
| 18 | dynamic. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 19 | * @cost: The cost coefficient associated with this level, used during |
| 20 | * energy calculation. Equal to: power * max_frequency / frequency |
| 21 | */ |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 22 | struct em_perf_state { |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 23 | unsigned long frequency; |
| 24 | unsigned long power; |
| 25 | unsigned long cost; |
| 26 | }; |
| 27 | |
| 28 | /** |
| 29 | * em_perf_domain - Performance domain |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 30 | * @table: List of performance states, in ascending order |
| 31 | * @nr_perf_states: Number of performance states |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 32 | * @cpus: Cpumask covering the CPUs of the domain. It's here |
| 33 | * for performance reasons to avoid potential cache |
| 34 | * misses during energy calculations in the scheduler |
| 35 | * and simplifies allocating/freeing that memory region. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 36 | * |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 37 | * In case of CPU device, a "performance domain" represents a group of CPUs |
| 38 | * whose performance is scaled together. All CPUs of a performance domain |
| 39 | * must have the same micro-architecture. Performance domains often have |
| 40 | * a 1-to-1 mapping with CPUFreq policies. In case of other devices the @cpus |
| 41 | * field is unused. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 42 | */ |
| 43 | struct em_perf_domain { |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 44 | struct em_perf_state *table; |
| 45 | int nr_perf_states; |
Gustavo A. R. Silva | beb69f1 | 2020-03-23 17:23:01 -0500 | [diff] [blame] | 46 | unsigned long cpus[]; |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 47 | }; |
| 48 | |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 49 | #define em_span_cpus(em) (to_cpumask((em)->cpus)) |
| 50 | |
Quentin Perret | 27a47e4 | 2019-10-30 15:14:49 +0000 | [diff] [blame] | 51 | #ifdef CONFIG_ENERGY_MODEL |
Lukasz Luba | 7d9895c | 2020-05-27 10:58:48 +0100 | [diff] [blame] | 52 | #define EM_MAX_POWER 0xFFFF |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 53 | |
Lukasz Luba | d6337df | 2021-08-03 11:27:43 +0100 | [diff] [blame] | 54 | /* |
| 55 | * Increase resolution of energy estimation calculations for 64-bit |
| 56 | * architectures. The extra resolution improves decision made by EAS for the |
| 57 | * task placement when two Performance Domains might provide similar energy |
| 58 | * estimation values (w/o better resolution the values could be equal). |
| 59 | * |
| 60 | * We increase resolution only if we have enough bits to allow this increased |
| 61 | * resolution (i.e. 64-bit). The costs for increasing resolution when 32-bit |
| 62 | * are pretty high and the returns do not justify the increased costs. |
| 63 | */ |
| 64 | #ifdef CONFIG_64BIT |
| 65 | #define em_scale_power(p) ((p) * 1000) |
| 66 | #else |
| 67 | #define em_scale_power(p) (p) |
| 68 | #endif |
| 69 | |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 70 | struct em_data_callback { |
| 71 | /** |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 72 | * active_power() - Provide power at the next performance state of |
Lukasz Luba | d0351cc | 2020-05-27 10:58:49 +0100 | [diff] [blame] | 73 | * a device |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 74 | * @power : Active power at the performance state in mW |
| 75 | * (modified) |
| 76 | * @freq : Frequency at the performance state in kHz |
| 77 | * (modified) |
Lukasz Luba | d0351cc | 2020-05-27 10:58:49 +0100 | [diff] [blame] | 78 | * @dev : Device for which we do this operation (can be a CPU) |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 79 | * |
Lukasz Luba | d0351cc | 2020-05-27 10:58:49 +0100 | [diff] [blame] | 80 | * active_power() must find the lowest performance state of 'dev' above |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 81 | * 'freq' and update 'power' and 'freq' to the matching active power |
| 82 | * and frequency. |
| 83 | * |
Lukasz Luba | d0351cc | 2020-05-27 10:58:49 +0100 | [diff] [blame] | 84 | * In case of CPUs, the power is the one of a single CPU in the domain, |
| 85 | * expressed in milli-watts. It is expected to fit in the |
| 86 | * [0, EM_MAX_POWER] range. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 87 | * |
| 88 | * Return 0 on success. |
| 89 | */ |
Lukasz Luba | d0351cc | 2020-05-27 10:58:49 +0100 | [diff] [blame] | 90 | int (*active_power)(unsigned long *power, unsigned long *freq, |
| 91 | struct device *dev); |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 92 | }; |
| 93 | #define EM_DATA_CB(_active_power_cb) { .active_power = &_active_power_cb } |
| 94 | |
| 95 | struct em_perf_domain *em_cpu_get(int cpu); |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 96 | struct em_perf_domain *em_pd_get(struct device *dev); |
Lukasz Luba | 7d9895c | 2020-05-27 10:58:48 +0100 | [diff] [blame] | 97 | int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, |
| 98 | struct em_data_callback *cb, cpumask_t *span); |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 99 | void em_dev_unregister_perf_domain(struct device *dev); |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 100 | |
| 101 | /** |
Lukasz Luba | f0b5694 | 2020-05-27 10:58:52 +0100 | [diff] [blame] | 102 | * em_cpu_energy() - Estimates the energy consumed by the CPUs of a |
| 103 | performance domain |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 104 | * @pd : performance domain for which energy has to be estimated |
| 105 | * @max_util : highest utilization among CPUs of the domain |
| 106 | * @sum_util : sum of the utilization of all CPUs in the domain |
| 107 | * |
Lukasz Luba | f0b5694 | 2020-05-27 10:58:52 +0100 | [diff] [blame] | 108 | * This function must be used only for CPU devices. There is no validation, |
| 109 | * i.e. if the EM is a CPU type and has cpumask allocated. It is called from |
| 110 | * the scheduler code quite frequently and that is why there is not checks. |
| 111 | * |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 112 | * Return: the sum of the energy consumed by the CPUs of the domain assuming |
| 113 | * a capacity state satisfying the max utilization of the domain. |
| 114 | */ |
Lukasz Luba | f0b5694 | 2020-05-27 10:58:52 +0100 | [diff] [blame] | 115 | static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 116 | unsigned long max_util, unsigned long sum_util) |
| 117 | { |
| 118 | unsigned long freq, scale_cpu; |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 119 | struct em_perf_state *ps; |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 120 | int i, cpu; |
| 121 | |
| 122 | /* |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 123 | * In order to predict the performance state, map the utilization of |
| 124 | * the most utilized CPU of the performance domain to a requested |
| 125 | * frequency, like schedutil. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 126 | */ |
| 127 | cpu = cpumask_first(to_cpumask(pd->cpus)); |
Vincent Guittot | 8ec59c0 | 2019-06-17 17:00:17 +0200 | [diff] [blame] | 128 | scale_cpu = arch_scale_cpu_capacity(cpu); |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 129 | ps = &pd->table[pd->nr_perf_states - 1]; |
| 130 | freq = map_util_freq(max_util, ps->frequency, scale_cpu); |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 131 | |
| 132 | /* |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 133 | * Find the lowest performance state of the Energy Model above the |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 134 | * requested frequency. |
| 135 | */ |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 136 | for (i = 0; i < pd->nr_perf_states; i++) { |
| 137 | ps = &pd->table[i]; |
| 138 | if (ps->frequency >= freq) |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 139 | break; |
| 140 | } |
| 141 | |
| 142 | /* |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 143 | * The capacity of a CPU in the domain at the performance state (ps) |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 144 | * can be computed as: |
| 145 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 146 | * ps->freq * scale_cpu |
| 147 | * ps->cap = -------------------- (1) |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 148 | * cpu_max_freq |
| 149 | * |
| 150 | * So, ignoring the costs of idle states (which are not available in |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 151 | * the EM), the energy consumed by this CPU at that performance state |
| 152 | * is estimated as: |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 153 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 154 | * ps->power * cpu_util |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 155 | * cpu_nrg = -------------------- (2) |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 156 | * ps->cap |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 157 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 158 | * since 'cpu_util / ps->cap' represents its percentage of busy time. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 159 | * |
| 160 | * NOTE: Although the result of this computation actually is in |
| 161 | * units of power, it can be manipulated as an energy value |
| 162 | * over a scheduling period, since it is assumed to be |
| 163 | * constant during that interval. |
| 164 | * |
| 165 | * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product |
| 166 | * of two terms: |
| 167 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 168 | * ps->power * cpu_max_freq cpu_util |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 169 | * cpu_nrg = ------------------------ * --------- (3) |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 170 | * ps->freq scale_cpu |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 171 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 172 | * The first term is static, and is stored in the em_perf_state struct |
| 173 | * as 'ps->cost'. |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 174 | * |
| 175 | * Since all CPUs of the domain have the same micro-architecture, they |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 176 | * share the same 'ps->cost', and the same CPU capacity. Hence, the |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 177 | * total energy of the domain (which is the simple sum of the energy of |
| 178 | * all of its CPUs) can be factorized as: |
| 179 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 180 | * ps->cost * \Sum cpu_util |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 181 | * pd_nrg = ------------------------ (4) |
| 182 | * scale_cpu |
| 183 | */ |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 184 | return ps->cost * sum_util / scale_cpu; |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | /** |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 188 | * em_pd_nr_perf_states() - Get the number of performance states of a perf. |
| 189 | * domain |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 190 | * @pd : performance domain for which this must be done |
| 191 | * |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 192 | * Return: the number of performance states in the performance domain table |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 193 | */ |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 194 | static inline int em_pd_nr_perf_states(struct em_perf_domain *pd) |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 195 | { |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 196 | return pd->nr_perf_states; |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 197 | } |
| 198 | |
| 199 | #else |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 200 | struct em_data_callback {}; |
| 201 | #define EM_DATA_CB(_active_power_cb) { } |
| 202 | |
Lukasz Luba | 7d9895c | 2020-05-27 10:58:48 +0100 | [diff] [blame] | 203 | static inline |
| 204 | int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, |
| 205 | struct em_data_callback *cb, cpumask_t *span) |
| 206 | { |
| 207 | return -EINVAL; |
| 208 | } |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 209 | static inline void em_dev_unregister_perf_domain(struct device *dev) |
| 210 | { |
| 211 | } |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 212 | static inline struct em_perf_domain *em_cpu_get(int cpu) |
| 213 | { |
| 214 | return NULL; |
| 215 | } |
Lukasz Luba | 1bc138c | 2020-06-10 11:12:23 +0100 | [diff] [blame] | 216 | static inline struct em_perf_domain *em_pd_get(struct device *dev) |
| 217 | { |
| 218 | return NULL; |
| 219 | } |
Lukasz Luba | f0b5694 | 2020-05-27 10:58:52 +0100 | [diff] [blame] | 220 | static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 221 | unsigned long max_util, unsigned long sum_util) |
| 222 | { |
| 223 | return 0; |
| 224 | } |
Lukasz Luba | 521b512 | 2020-05-27 10:58:47 +0100 | [diff] [blame] | 225 | static inline int em_pd_nr_perf_states(struct em_perf_domain *pd) |
Quentin Perret | 27871f7 | 2018-12-03 09:56:16 +0000 | [diff] [blame] | 226 | { |
| 227 | return 0; |
| 228 | } |
| 229 | #endif |
| 230 | |
| 231 | #endif |