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 */ 21struct em_perf_state { 22 unsigned long frequency; 23 unsigned long power; 24 unsigned long cost; 25}; 26 27/** 28 * struct em_perf_domain - Performance domain 29 * @table: List of performance states, in ascending order 30 * @nr_perf_states: Number of performance states 31 * @milliwatts: Flag indicating the power values are in milli-Watts 32 * or some other scale. 33 * @cpus: Cpumask covering the CPUs of the domain. It's here 34 * for performance reasons to avoid potential cache 35 * misses during energy calculations in the scheduler 36 * and simplifies allocating/freeing that memory region. 37 * 38 * In case of CPU device, a "performance domain" represents a group of CPUs 39 * whose performance is scaled together. All CPUs of a performance domain 40 * must have the same micro-architecture. Performance domains often have 41 * a 1-to-1 mapping with CPUFreq policies. In case of other devices the @cpus 42 * field is unused. 43 */ 44struct em_perf_domain { 45 struct em_perf_state *table; 46 int nr_perf_states; 47 int milliwatts; 48 unsigned long cpus[]; 49}; 50 51#define em_span_cpus(em) (to_cpumask((em)->cpus)) 52 53#ifdef CONFIG_ENERGY_MODEL 54#define EM_MAX_POWER 0xFFFF 55 56/* 57 * Increase resolution of energy estimation calculations for 64-bit 58 * architectures. The extra resolution improves decision made by EAS for the 59 * task placement when two Performance Domains might provide similar energy 60 * estimation values (w/o better resolution the values could be equal). 61 * 62 * We increase resolution only if we have enough bits to allow this increased 63 * resolution (i.e. 64-bit). The costs for increasing resolution when 32-bit 64 * are pretty high and the returns do not justify the increased costs. 65 */ 66#ifdef CONFIG_64BIT 67#define em_scale_power(p) ((p) * 1000) 68#else 69#define em_scale_power(p) (p) 70#endif 71 72struct em_data_callback { 73 /** 74 * active_power() - Provide power at the next performance state of 75 * a device 76 * @power : Active power at the performance state 77 * (modified) 78 * @freq : Frequency at the performance state in kHz 79 * (modified) 80 * @dev : Device for which we do this operation (can be a CPU) 81 * 82 * active_power() must find the lowest performance state of 'dev' above 83 * 'freq' and update 'power' and 'freq' to the matching active power 84 * and frequency. 85 * 86 * In case of CPUs, the power is the one of a single CPU in the domain, 87 * expressed in milli-Watts or an abstract scale. It is expected to 88 * fit in the [0, EM_MAX_POWER] range. 89 * 90 * Return 0 on success. 91 */ 92 int (*active_power)(unsigned long *power, unsigned long *freq, 93 struct device *dev); 94}; 95#define EM_DATA_CB(_active_power_cb) { .active_power = &_active_power_cb } 96 97struct em_perf_domain *em_cpu_get(int cpu); 98struct em_perf_domain *em_pd_get(struct device *dev); 99int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, 100 struct em_data_callback *cb, cpumask_t *span, 101 bool milliwatts); 102void em_dev_unregister_perf_domain(struct device *dev); 103 104/** 105 * em_cpu_energy() - Estimates the energy consumed by the CPUs of a 106 * performance domain 107 * @pd : performance domain for which energy has to be estimated 108 * @max_util : highest utilization among CPUs of the domain 109 * @sum_util : sum of the utilization of all CPUs in the domain 110 * @allowed_cpu_cap : maximum allowed CPU capacity for the @pd, which 111 * might reflect reduced frequency (due to thermal) 112 * 113 * This function must be used only for CPU devices. There is no validation, 114 * i.e. if the EM is a CPU type and has cpumask allocated. It is called from 115 * the scheduler code quite frequently and that is why there is not checks. 116 * 117 * Return: the sum of the energy consumed by the CPUs of the domain assuming 118 * a capacity state satisfying the max utilization of the domain. 119 */ 120static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, 121 unsigned long max_util, unsigned long sum_util, 122 unsigned long allowed_cpu_cap) 123{ 124 unsigned long freq, scale_cpu; 125 struct em_perf_state *ps; 126 int i, cpu; 127 128 if (!sum_util) 129 return 0; 130 131 /* 132 * In order to predict the performance state, map the utilization of 133 * the most utilized CPU of the performance domain to a requested 134 * frequency, like schedutil. Take also into account that the real 135 * frequency might be set lower (due to thermal capping). Thus, clamp 136 * max utilization to the allowed CPU capacity before calculating 137 * effective frequency. 138 */ 139 cpu = cpumask_first(to_cpumask(pd->cpus)); 140 scale_cpu = arch_scale_cpu_capacity(cpu); 141 ps = &pd->table[pd->nr_perf_states - 1]; 142 143 max_util = map_util_perf(max_util); 144 max_util = min(max_util, allowed_cpu_cap); 145 freq = map_util_freq(max_util, ps->frequency, scale_cpu); 146 147 /* 148 * Find the lowest performance state of the Energy Model above the 149 * requested frequency. 150 */ 151 for (i = 0; i < pd->nr_perf_states; i++) { 152 ps = &pd->table[i]; 153 if (ps->frequency >= freq) 154 break; 155 } 156 157 /* 158 * The capacity of a CPU in the domain at the performance state (ps) 159 * can be computed as: 160 * 161 * ps->freq * scale_cpu 162 * ps->cap = -------------------- (1) 163 * cpu_max_freq 164 * 165 * So, ignoring the costs of idle states (which are not available in 166 * the EM), the energy consumed by this CPU at that performance state 167 * is estimated as: 168 * 169 * ps->power * cpu_util 170 * cpu_nrg = -------------------- (2) 171 * ps->cap 172 * 173 * since 'cpu_util / ps->cap' represents its percentage of busy time. 174 * 175 * NOTE: Although the result of this computation actually is in 176 * units of power, it can be manipulated as an energy value 177 * over a scheduling period, since it is assumed to be 178 * constant during that interval. 179 * 180 * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product 181 * of two terms: 182 * 183 * ps->power * cpu_max_freq cpu_util 184 * cpu_nrg = ------------------------ * --------- (3) 185 * ps->freq scale_cpu 186 * 187 * The first term is static, and is stored in the em_perf_state struct 188 * as 'ps->cost'. 189 * 190 * Since all CPUs of the domain have the same micro-architecture, they 191 * share the same 'ps->cost', and the same CPU capacity. Hence, the 192 * total energy of the domain (which is the simple sum of the energy of 193 * all of its CPUs) can be factorized as: 194 * 195 * ps->cost * \Sum cpu_util 196 * pd_nrg = ------------------------ (4) 197 * scale_cpu 198 */ 199 return ps->cost * sum_util / scale_cpu; 200} 201 202/** 203 * em_pd_nr_perf_states() - Get the number of performance states of a perf. 204 * domain 205 * @pd : performance domain for which this must be done 206 * 207 * Return: the number of performance states in the performance domain table 208 */ 209static inline int em_pd_nr_perf_states(struct em_perf_domain *pd) 210{ 211 return pd->nr_perf_states; 212} 213 214#else 215struct em_data_callback {}; 216#define EM_DATA_CB(_active_power_cb) { } 217 218static inline 219int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, 220 struct em_data_callback *cb, cpumask_t *span, 221 bool milliwatts) 222{ 223 return -EINVAL; 224} 225static inline void em_dev_unregister_perf_domain(struct device *dev) 226{ 227} 228static inline struct em_perf_domain *em_cpu_get(int cpu) 229{ 230 return NULL; 231} 232static inline struct em_perf_domain *em_pd_get(struct device *dev) 233{ 234 return NULL; 235} 236static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, 237 unsigned long max_util, unsigned long sum_util, 238 unsigned long allowed_cpu_cap) 239{ 240 return 0; 241} 242static inline int em_pd_nr_perf_states(struct em_perf_domain *pd) 243{ 244 return 0; 245} 246#endif 247 248#endif 249