1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_ENERGY_MODEL_H 3 #define _LINUX_ENERGY_MODEL_H 4 #include <linux/cpumask.h> 5 #include <linux/device.h> 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 13 /** 14 * struct em_perf_state - Performance state of a performance domain 15 * @frequency: The frequency in KHz, for consistency with CPUFreq 16 * @power: The power consumed at this level (by 1 CPU or by a registered 17 * device). It can be a total power: static and dynamic. 18 * @cost: The cost coefficient associated with this level, used during 19 * energy calculation. Equal to: power * max_frequency / frequency 20 * @flags: see "em_perf_state flags" description below. 21 */ 22 struct em_perf_state { 23 unsigned long frequency; 24 unsigned long power; 25 unsigned long cost; 26 unsigned long flags; 27 }; 28 29 /* 30 * em_perf_state flags: 31 * 32 * EM_PERF_STATE_INEFFICIENT: The performance state is inefficient. There is 33 * in this em_perf_domain, another performance state with a higher frequency 34 * but a lower or equal power cost. Such inefficient states are ignored when 35 * using em_pd_get_efficient_*() functions. 36 */ 37 #define EM_PERF_STATE_INEFFICIENT BIT(0) 38 39 /** 40 * struct em_perf_domain - Performance domain 41 * @table: List of performance states, in ascending order 42 * @nr_perf_states: Number of performance states 43 * @flags: See "em_perf_domain flags" 44 * @cpus: Cpumask covering the CPUs of the domain. It's here 45 * for performance reasons to avoid potential cache 46 * misses during energy calculations in the scheduler 47 * and simplifies allocating/freeing that memory region. 48 * 49 * In case of CPU device, a "performance domain" represents a group of CPUs 50 * whose performance is scaled together. All CPUs of a performance domain 51 * must have the same micro-architecture. Performance domains often have 52 * a 1-to-1 mapping with CPUFreq policies. In case of other devices the @cpus 53 * field is unused. 54 */ 55 struct em_perf_domain { 56 struct em_perf_state *table; 57 int nr_perf_states; 58 unsigned long flags; 59 unsigned long cpus[]; 60 }; 61 62 /* 63 * em_perf_domain flags: 64 * 65 * EM_PERF_DOMAIN_MICROWATTS: The power values are in micro-Watts or some 66 * other scale. 67 * 68 * EM_PERF_DOMAIN_SKIP_INEFFICIENCIES: Skip inefficient states when estimating 69 * energy consumption. 70 * 71 * EM_PERF_DOMAIN_ARTIFICIAL: The power values are artificial and might be 72 * created by platform missing real power information 73 */ 74 #define EM_PERF_DOMAIN_MICROWATTS BIT(0) 75 #define EM_PERF_DOMAIN_SKIP_INEFFICIENCIES BIT(1) 76 #define EM_PERF_DOMAIN_ARTIFICIAL BIT(2) 77 78 #define em_span_cpus(em) (to_cpumask((em)->cpus)) 79 #define em_is_artificial(em) ((em)->flags & EM_PERF_DOMAIN_ARTIFICIAL) 80 81 #ifdef CONFIG_ENERGY_MODEL 82 /* 83 * The max power value in micro-Watts. The limit of 64 Watts is set as 84 * a safety net to not overflow multiplications on 32bit platforms. The 85 * 32bit value limit for total Perf Domain power implies a limit of 86 * maximum CPUs in such domain to 64. 87 */ 88 #define EM_MAX_POWER (64000000) /* 64 Watts */ 89 90 /* 91 * To avoid possible energy estimation overflow on 32bit machines add 92 * limits to number of CPUs in the Perf. Domain. 93 * We are safe on 64bit machine, thus some big number. 94 */ 95 #ifdef CONFIG_64BIT 96 #define EM_MAX_NUM_CPUS 4096 97 #else 98 #define EM_MAX_NUM_CPUS 16 99 #endif 100 101 /* 102 * To avoid an overflow on 32bit machines while calculating the energy 103 * use a different order in the operation. First divide by the 'cpu_scale' 104 * which would reduce big value stored in the 'cost' field, then multiply by 105 * the 'sum_util'. This would allow to handle existing platforms, which have 106 * e.g. power ~1.3 Watt at max freq, so the 'cost' value > 1mln micro-Watts. 107 * In such scenario, where there are 4 CPUs in the Perf. Domain the 'sum_util' 108 * could be 4096, then multiplication: 'cost' * 'sum_util' would overflow. 109 * This reordering of operations has some limitations, we lose small 110 * precision in the estimation (comparing to 64bit platform w/o reordering). 111 * 112 * We are safe on 64bit machine. 113 */ 114 #ifdef CONFIG_64BIT 115 #define em_estimate_energy(cost, sum_util, scale_cpu) \ 116 (((cost) * (sum_util)) / (scale_cpu)) 117 #else 118 #define em_estimate_energy(cost, sum_util, scale_cpu) \ 119 (((cost) / (scale_cpu)) * (sum_util)) 120 #endif 121 122 struct em_data_callback { 123 /** 124 * active_power() - Provide power at the next performance state of 125 * a device 126 * @dev : Device for which we do this operation (can be a CPU) 127 * @power : Active power at the performance state 128 * (modified) 129 * @freq : Frequency at the performance state in kHz 130 * (modified) 131 * 132 * active_power() must find the lowest performance state of 'dev' above 133 * 'freq' and update 'power' and 'freq' to the matching active power 134 * and frequency. 135 * 136 * In case of CPUs, the power is the one of a single CPU in the domain, 137 * expressed in micro-Watts or an abstract scale. It is expected to 138 * fit in the [0, EM_MAX_POWER] range. 139 * 140 * Return 0 on success. 141 */ 142 int (*active_power)(struct device *dev, unsigned long *power, 143 unsigned long *freq); 144 145 /** 146 * get_cost() - Provide the cost at the given performance state of 147 * a device 148 * @dev : Device for which we do this operation (can be a CPU) 149 * @freq : Frequency at the performance state in kHz 150 * @cost : The cost value for the performance state 151 * (modified) 152 * 153 * In case of CPUs, the cost is the one of a single CPU in the domain. 154 * It is expected to fit in the [0, EM_MAX_POWER] range due to internal 155 * usage in EAS calculation. 156 * 157 * Return 0 on success, or appropriate error value in case of failure. 158 */ 159 int (*get_cost)(struct device *dev, unsigned long freq, 160 unsigned long *cost); 161 }; 162 #define EM_SET_ACTIVE_POWER_CB(em_cb, cb) ((em_cb).active_power = cb) 163 #define EM_ADV_DATA_CB(_active_power_cb, _cost_cb) \ 164 { .active_power = _active_power_cb, \ 165 .get_cost = _cost_cb } 166 #define EM_DATA_CB(_active_power_cb) \ 167 EM_ADV_DATA_CB(_active_power_cb, NULL) 168 169 struct em_perf_domain *em_cpu_get(int cpu); 170 struct em_perf_domain *em_pd_get(struct device *dev); 171 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, 172 struct em_data_callback *cb, cpumask_t *span, 173 bool microwatts); 174 void em_dev_unregister_perf_domain(struct device *dev); 175 176 /** 177 * em_pd_get_efficient_state() - Get an efficient performance state from the EM 178 * @pd : Performance domain for which we want an efficient frequency 179 * @freq : Frequency to map with the EM 180 * 181 * It is called from the scheduler code quite frequently and as a consequence 182 * doesn't implement any check. 183 * 184 * Return: An efficient performance state, high enough to meet @freq 185 * requirement. 186 */ 187 static inline 188 struct em_perf_state *em_pd_get_efficient_state(struct em_perf_domain *pd, 189 unsigned long freq) 190 { 191 struct em_perf_state *ps; 192 int i; 193 194 for (i = 0; i < pd->nr_perf_states; i++) { 195 ps = &pd->table[i]; 196 if (ps->frequency >= freq) { 197 if (pd->flags & EM_PERF_DOMAIN_SKIP_INEFFICIENCIES && 198 ps->flags & EM_PERF_STATE_INEFFICIENT) 199 continue; 200 break; 201 } 202 } 203 204 return ps; 205 } 206 207 /** 208 * em_cpu_energy() - Estimates the energy consumed by the CPUs of a 209 * performance domain 210 * @pd : performance domain for which energy has to be estimated 211 * @max_util : highest utilization among CPUs of the domain 212 * @sum_util : sum of the utilization of all CPUs in the domain 213 * @allowed_cpu_cap : maximum allowed CPU capacity for the @pd, which 214 * might reflect reduced frequency (due to thermal) 215 * 216 * This function must be used only for CPU devices. There is no validation, 217 * i.e. if the EM is a CPU type and has cpumask allocated. It is called from 218 * the scheduler code quite frequently and that is why there is not checks. 219 * 220 * Return: the sum of the energy consumed by the CPUs of the domain assuming 221 * a capacity state satisfying the max utilization of the domain. 222 */ 223 static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, 224 unsigned long max_util, unsigned long sum_util, 225 unsigned long allowed_cpu_cap) 226 { 227 unsigned long freq, scale_cpu; 228 struct em_perf_state *ps; 229 int cpu; 230 231 if (!sum_util) 232 return 0; 233 234 /* 235 * In order to predict the performance state, map the utilization of 236 * the most utilized CPU of the performance domain to a requested 237 * frequency, like schedutil. Take also into account that the real 238 * frequency might be set lower (due to thermal capping). Thus, clamp 239 * max utilization to the allowed CPU capacity before calculating 240 * effective frequency. 241 */ 242 cpu = cpumask_first(to_cpumask(pd->cpus)); 243 scale_cpu = arch_scale_cpu_capacity(cpu); 244 ps = &pd->table[pd->nr_perf_states - 1]; 245 246 max_util = map_util_perf(max_util); 247 max_util = min(max_util, allowed_cpu_cap); 248 freq = map_util_freq(max_util, ps->frequency, scale_cpu); 249 250 /* 251 * Find the lowest performance state of the Energy Model above the 252 * requested frequency. 253 */ 254 ps = em_pd_get_efficient_state(pd, freq); 255 256 /* 257 * The capacity of a CPU in the domain at the performance state (ps) 258 * can be computed as: 259 * 260 * ps->freq * scale_cpu 261 * ps->cap = -------------------- (1) 262 * cpu_max_freq 263 * 264 * So, ignoring the costs of idle states (which are not available in 265 * the EM), the energy consumed by this CPU at that performance state 266 * is estimated as: 267 * 268 * ps->power * cpu_util 269 * cpu_nrg = -------------------- (2) 270 * ps->cap 271 * 272 * since 'cpu_util / ps->cap' represents its percentage of busy time. 273 * 274 * NOTE: Although the result of this computation actually is in 275 * units of power, it can be manipulated as an energy value 276 * over a scheduling period, since it is assumed to be 277 * constant during that interval. 278 * 279 * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product 280 * of two terms: 281 * 282 * ps->power * cpu_max_freq cpu_util 283 * cpu_nrg = ------------------------ * --------- (3) 284 * ps->freq scale_cpu 285 * 286 * The first term is static, and is stored in the em_perf_state struct 287 * as 'ps->cost'. 288 * 289 * Since all CPUs of the domain have the same micro-architecture, they 290 * share the same 'ps->cost', and the same CPU capacity. Hence, the 291 * total energy of the domain (which is the simple sum of the energy of 292 * all of its CPUs) can be factorized as: 293 * 294 * ps->cost * \Sum cpu_util 295 * pd_nrg = ------------------------ (4) 296 * scale_cpu 297 */ 298 return em_estimate_energy(ps->cost, sum_util, scale_cpu); 299 } 300 301 /** 302 * em_pd_nr_perf_states() - Get the number of performance states of a perf. 303 * domain 304 * @pd : performance domain for which this must be done 305 * 306 * Return: the number of performance states in the performance domain table 307 */ 308 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd) 309 { 310 return pd->nr_perf_states; 311 } 312 313 #else 314 struct em_data_callback {}; 315 #define EM_ADV_DATA_CB(_active_power_cb, _cost_cb) { } 316 #define EM_DATA_CB(_active_power_cb) { } 317 #define EM_SET_ACTIVE_POWER_CB(em_cb, cb) do { } while (0) 318 319 static inline 320 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, 321 struct em_data_callback *cb, cpumask_t *span, 322 bool microwatts) 323 { 324 return -EINVAL; 325 } 326 static inline void em_dev_unregister_perf_domain(struct device *dev) 327 { 328 } 329 static inline struct em_perf_domain *em_cpu_get(int cpu) 330 { 331 return NULL; 332 } 333 static inline struct em_perf_domain *em_pd_get(struct device *dev) 334 { 335 return NULL; 336 } 337 static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, 338 unsigned long max_util, unsigned long sum_util, 339 unsigned long allowed_cpu_cap) 340 { 341 return 0; 342 } 343 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd) 344 { 345 return 0; 346 } 347 #endif 348 349 #endif 350