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/jump_label.h>
6 #include <linux/kobject.h>
7 #include <linux/rcupdate.h>
8 #include <linux/sched/cpufreq.h>
9 #include <linux/sched/topology.h>
10 #include <linux/types.h>
12 #ifdef CONFIG_ENERGY_MODEL
14 * em_cap_state - Capacity state of a performance domain
15 * @frequency: The CPU frequency in KHz, for consistency with CPUFreq
16 * @power: The power consumed by 1 CPU at this level, in milli-watts
17 * @cost: The cost coefficient associated with this level, used during
18 * energy calculation. Equal to: power * max_frequency / frequency
21 unsigned long frequency;
27 * em_perf_domain - Performance domain
28 * @table: List of capacity states, in ascending order
29 * @nr_cap_states: Number of capacity states
30 * @cpus: Cpumask covering the CPUs of the domain
32 * A "performance domain" represents a group of CPUs whose performance is
33 * scaled together. All CPUs of a performance domain must have the same
34 * micro-architecture. Performance domains often have a 1-to-1 mapping with
37 struct em_perf_domain {
38 struct em_cap_state *table;
40 unsigned long cpus[0];
43 #define EM_CPU_MAX_POWER 0xFFFF
46 * Increase resolution of energy estimation calculations for 64-bit
47 * architectures. The extra resolution improves decision made by EAS for the
48 * task placement when two Performance Domains might provide similar energy
49 * estimation values (w/o better resolution the values could be equal).
51 * We increase resolution only if we have enough bits to allow this increased
52 * resolution (i.e. 64-bit). The costs for increasing resolution when 32-bit
53 * are pretty high and the returns do not justify the increased costs.
56 #define em_scale_power(p) ((p) * 1000)
58 #define em_scale_power(p) (p)
61 struct em_data_callback {
63 * active_power() - Provide power at the next capacity state of a CPU
64 * @power : Active power at the capacity state in mW (modified)
65 * @freq : Frequency at the capacity state in kHz (modified)
66 * @cpu : CPU for which we do this operation
68 * active_power() must find the lowest capacity state of 'cpu' above
69 * 'freq' and update 'power' and 'freq' to the matching active power
72 * The power is the one of a single CPU in the domain, expressed in
73 * milli-watts. It is expected to fit in the [0, EM_CPU_MAX_POWER]
76 * Return 0 on success.
78 int (*active_power)(unsigned long *power, unsigned long *freq, int cpu);
80 #define EM_DATA_CB(_active_power_cb) { .active_power = &_active_power_cb }
82 struct em_perf_domain *em_cpu_get(int cpu);
83 int em_register_perf_domain(cpumask_t *span, unsigned int nr_states,
84 struct em_data_callback *cb);
87 * em_pd_energy() - Estimates the energy consumed by the CPUs of a perf. domain
88 * @pd : performance domain for which energy has to be estimated
89 * @max_util : highest utilization among CPUs of the domain
90 * @sum_util : sum of the utilization of all CPUs in the domain
92 * Return: the sum of the energy consumed by the CPUs of the domain assuming
93 * a capacity state satisfying the max utilization of the domain.
95 static inline unsigned long em_pd_energy(struct em_perf_domain *pd,
96 unsigned long max_util, unsigned long sum_util)
98 unsigned long freq, scale_cpu;
99 struct em_cap_state *cs;
103 * In order to predict the capacity state, map the utilization of the
104 * most utilized CPU of the performance domain to a requested frequency,
107 cpu = cpumask_first(to_cpumask(pd->cpus));
108 scale_cpu = arch_scale_cpu_capacity(cpu);
109 cs = &pd->table[pd->nr_cap_states - 1];
110 freq = map_util_freq(max_util, cs->frequency, scale_cpu);
113 * Find the lowest capacity state of the Energy Model above the
114 * requested frequency.
116 for (i = 0; i < pd->nr_cap_states; i++) {
118 if (cs->frequency >= freq)
123 * The capacity of a CPU in the domain at that capacity state (cs)
124 * can be computed as:
126 * cs->freq * scale_cpu
127 * cs->cap = -------------------- (1)
130 * So, ignoring the costs of idle states (which are not available in
131 * the EM), the energy consumed by this CPU at that capacity state is
134 * cs->power * cpu_util
135 * cpu_nrg = -------------------- (2)
138 * since 'cpu_util / cs->cap' represents its percentage of busy time.
140 * NOTE: Although the result of this computation actually is in
141 * units of power, it can be manipulated as an energy value
142 * over a scheduling period, since it is assumed to be
143 * constant during that interval.
145 * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product
148 * cs->power * cpu_max_freq cpu_util
149 * cpu_nrg = ------------------------ * --------- (3)
152 * The first term is static, and is stored in the em_cap_state struct
155 * Since all CPUs of the domain have the same micro-architecture, they
156 * share the same 'cs->cost', and the same CPU capacity. Hence, the
157 * total energy of the domain (which is the simple sum of the energy of
158 * all of its CPUs) can be factorized as:
160 * cs->cost * \Sum cpu_util
161 * pd_nrg = ------------------------ (4)
164 return cs->cost * sum_util / scale_cpu;
168 * em_pd_nr_cap_states() - Get the number of capacity states of a perf. domain
169 * @pd : performance domain for which this must be done
171 * Return: the number of capacity states in the performance domain table
173 static inline int em_pd_nr_cap_states(struct em_perf_domain *pd)
175 return pd->nr_cap_states;
179 struct em_perf_domain {};
180 struct em_data_callback {};
181 #define EM_DATA_CB(_active_power_cb) { }
183 static inline int em_register_perf_domain(cpumask_t *span,
184 unsigned int nr_states, struct em_data_callback *cb)
188 static inline struct em_perf_domain *em_cpu_get(int cpu)
192 static inline unsigned long em_pd_energy(struct em_perf_domain *pd,
193 unsigned long max_util, unsigned long sum_util)
197 static inline int em_pd_nr_cap_states(struct em_perf_domain *pd)