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_MILLIWATTS: The power values are in milli-Watts or some
66 * other scale.
67 *
68 * EM_PERF_DOMAIN_SKIP_INEFFICIENCIES: Skip inefficient states when estimating
69 * energy consumption.
70 */
71 #define EM_PERF_DOMAIN_MILLIWATTS BIT(0)
72 #define EM_PERF_DOMAIN_SKIP_INEFFICIENCIES BIT(1)
73
74 #define em_span_cpus(em) (to_cpumask((em)->cpus))
75
76 #ifdef CONFIG_ENERGY_MODEL
77 #define EM_MAX_POWER 0xFFFF
78
79 /*
80 * Increase resolution of energy estimation calculations for 64-bit
81 * architectures. The extra resolution improves decision made by EAS for the
82 * task placement when two Performance Domains might provide similar energy
83 * estimation values (w/o better resolution the values could be equal).
84 *
85 * We increase resolution only if we have enough bits to allow this increased
86 * resolution (i.e. 64-bit). The costs for increasing resolution when 32-bit
87 * are pretty high and the returns do not justify the increased costs.
88 */
89 #ifdef CONFIG_64BIT
90 #define em_scale_power(p) ((p) * 1000)
91 #else
92 #define em_scale_power(p) (p)
93 #endif
94
95 struct em_data_callback {
96 /**
97 * active_power() - Provide power at the next performance state of
98 * a device
99 * @power : Active power at the performance state
100 * (modified)
101 * @freq : Frequency at the performance state in kHz
102 * (modified)
103 * @dev : Device for which we do this operation (can be a CPU)
104 *
105 * active_power() must find the lowest performance state of 'dev' above
106 * 'freq' and update 'power' and 'freq' to the matching active power
107 * and frequency.
108 *
109 * In case of CPUs, the power is the one of a single CPU in the domain,
110 * expressed in milli-Watts or an abstract scale. It is expected to
111 * fit in the [0, EM_MAX_POWER] range.
112 *
113 * Return 0 on success.
114 */
115 int (*active_power)(unsigned long *power, unsigned long *freq,
116 struct device *dev);
117 };
118 #define EM_DATA_CB(_active_power_cb) { .active_power = &_active_power_cb }
119
120 struct em_perf_domain *em_cpu_get(int cpu);
121 struct em_perf_domain *em_pd_get(struct device *dev);
122 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
123 struct em_data_callback *cb, cpumask_t *span,
124 bool milliwatts);
125 void em_dev_unregister_perf_domain(struct device *dev);
126
127 /**
128 * em_pd_get_efficient_state() - Get an efficient performance state from the EM
129 * @pd : Performance domain for which we want an efficient frequency
130 * @freq : Frequency to map with the EM
131 *
132 * It is called from the scheduler code quite frequently and as a consequence
133 * doesn't implement any check.
134 *
135 * Return: An efficient performance state, high enough to meet @freq
136 * requirement.
137 */
138 static inline
em_pd_get_efficient_state(struct em_perf_domain * pd,unsigned long freq)139 struct em_perf_state *em_pd_get_efficient_state(struct em_perf_domain *pd,
140 unsigned long freq)
141 {
142 struct em_perf_state *ps;
143 int i;
144
145 for (i = 0; i < pd->nr_perf_states; i++) {
146 ps = &pd->table[i];
147 if (ps->frequency >= freq) {
148 if (pd->flags & EM_PERF_DOMAIN_SKIP_INEFFICIENCIES &&
149 ps->flags & EM_PERF_STATE_INEFFICIENT)
150 continue;
151 break;
152 }
153 }
154
155 return ps;
156 }
157
158 /**
159 * em_cpu_energy() - Estimates the energy consumed by the CPUs of a
160 * performance domain
161 * @pd : performance domain for which energy has to be estimated
162 * @max_util : highest utilization among CPUs of the domain
163 * @sum_util : sum of the utilization of all CPUs in the domain
164 * @allowed_cpu_cap : maximum allowed CPU capacity for the @pd, which
165 * might reflect reduced frequency (due to thermal)
166 *
167 * This function must be used only for CPU devices. There is no validation,
168 * i.e. if the EM is a CPU type and has cpumask allocated. It is called from
169 * the scheduler code quite frequently and that is why there is not checks.
170 *
171 * Return: the sum of the energy consumed by the CPUs of the domain assuming
172 * a capacity state satisfying the max utilization of the domain.
173 */
em_cpu_energy(struct em_perf_domain * pd,unsigned long max_util,unsigned long sum_util,unsigned long allowed_cpu_cap)174 static inline unsigned long em_cpu_energy(struct em_perf_domain *pd,
175 unsigned long max_util, unsigned long sum_util,
176 unsigned long allowed_cpu_cap)
177 {
178 unsigned long freq, scale_cpu;
179 struct em_perf_state *ps;
180 int cpu;
181
182 if (!sum_util)
183 return 0;
184
185 /*
186 * In order to predict the performance state, map the utilization of
187 * the most utilized CPU of the performance domain to a requested
188 * frequency, like schedutil. Take also into account that the real
189 * frequency might be set lower (due to thermal capping). Thus, clamp
190 * max utilization to the allowed CPU capacity before calculating
191 * effective frequency.
192 */
193 cpu = cpumask_first(to_cpumask(pd->cpus));
194 scale_cpu = arch_scale_cpu_capacity(cpu);
195 ps = &pd->table[pd->nr_perf_states - 1];
196
197 max_util = map_util_perf(max_util);
198 max_util = min(max_util, allowed_cpu_cap);
199 freq = map_util_freq(max_util, ps->frequency, scale_cpu);
200
201 /*
202 * Find the lowest performance state of the Energy Model above the
203 * requested frequency.
204 */
205 ps = em_pd_get_efficient_state(pd, freq);
206
207 /*
208 * The capacity of a CPU in the domain at the performance state (ps)
209 * can be computed as:
210 *
211 * ps->freq * scale_cpu
212 * ps->cap = -------------------- (1)
213 * cpu_max_freq
214 *
215 * So, ignoring the costs of idle states (which are not available in
216 * the EM), the energy consumed by this CPU at that performance state
217 * is estimated as:
218 *
219 * ps->power * cpu_util
220 * cpu_nrg = -------------------- (2)
221 * ps->cap
222 *
223 * since 'cpu_util / ps->cap' represents its percentage of busy time.
224 *
225 * NOTE: Although the result of this computation actually is in
226 * units of power, it can be manipulated as an energy value
227 * over a scheduling period, since it is assumed to be
228 * constant during that interval.
229 *
230 * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product
231 * of two terms:
232 *
233 * ps->power * cpu_max_freq cpu_util
234 * cpu_nrg = ------------------------ * --------- (3)
235 * ps->freq scale_cpu
236 *
237 * The first term is static, and is stored in the em_perf_state struct
238 * as 'ps->cost'.
239 *
240 * Since all CPUs of the domain have the same micro-architecture, they
241 * share the same 'ps->cost', and the same CPU capacity. Hence, the
242 * total energy of the domain (which is the simple sum of the energy of
243 * all of its CPUs) can be factorized as:
244 *
245 * ps->cost * \Sum cpu_util
246 * pd_nrg = ------------------------ (4)
247 * scale_cpu
248 */
249 return ps->cost * sum_util / scale_cpu;
250 }
251
252 /**
253 * em_pd_nr_perf_states() - Get the number of performance states of a perf.
254 * domain
255 * @pd : performance domain for which this must be done
256 *
257 * Return: the number of performance states in the performance domain table
258 */
em_pd_nr_perf_states(struct em_perf_domain * pd)259 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd)
260 {
261 return pd->nr_perf_states;
262 }
263
264 #else
265 struct em_data_callback {};
266 #define EM_DATA_CB(_active_power_cb) { }
267
268 static inline
em_dev_register_perf_domain(struct device * dev,unsigned int nr_states,struct em_data_callback * cb,cpumask_t * span,bool milliwatts)269 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
270 struct em_data_callback *cb, cpumask_t *span,
271 bool milliwatts)
272 {
273 return -EINVAL;
274 }
em_dev_unregister_perf_domain(struct device * dev)275 static inline void em_dev_unregister_perf_domain(struct device *dev)
276 {
277 }
em_cpu_get(int cpu)278 static inline struct em_perf_domain *em_cpu_get(int cpu)
279 {
280 return NULL;
281 }
em_pd_get(struct device * dev)282 static inline struct em_perf_domain *em_pd_get(struct device *dev)
283 {
284 return NULL;
285 }
em_cpu_energy(struct em_perf_domain * pd,unsigned long max_util,unsigned long sum_util,unsigned long allowed_cpu_cap)286 static inline unsigned long em_cpu_energy(struct em_perf_domain *pd,
287 unsigned long max_util, unsigned long sum_util,
288 unsigned long allowed_cpu_cap)
289 {
290 return 0;
291 }
em_pd_nr_perf_states(struct em_perf_domain * pd)292 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd)
293 {
294 return 0;
295 }
296 #endif
297
298 #endif
299