]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - include/linux/energy_model.h
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
45 struct em_data_callback
{
47 * active_power() - Provide power at the next capacity state of a CPU
48 * @power : Active power at the capacity state in mW (modified)
49 * @freq : Frequency at the capacity state in kHz (modified)
50 * @cpu : CPU for which we do this operation
52 * active_power() must find the lowest capacity state of 'cpu' above
53 * 'freq' and update 'power' and 'freq' to the matching active power
56 * The power is the one of a single CPU in the domain, expressed in
57 * milli-watts. It is expected to fit in the [0, EM_CPU_MAX_POWER]
60 * Return 0 on success.
62 int (*active_power
)(unsigned long *power
, unsigned long *freq
, int cpu
);
64 #define EM_DATA_CB(_active_power_cb) { .active_power = &_active_power_cb }
66 struct em_perf_domain
*em_cpu_get(int cpu
);
67 int em_register_perf_domain(cpumask_t
*span
, unsigned int nr_states
,
68 struct em_data_callback
*cb
);
71 * em_pd_energy() - Estimates the energy consumed by the CPUs of a perf. domain
72 * @pd : performance domain for which energy has to be estimated
73 * @max_util : highest utilization among CPUs of the domain
74 * @sum_util : sum of the utilization of all CPUs in the domain
76 * Return: the sum of the energy consumed by the CPUs of the domain assuming
77 * a capacity state satisfying the max utilization of the domain.
79 static inline unsigned long em_pd_energy(struct em_perf_domain
*pd
,
80 unsigned long max_util
, unsigned long sum_util
)
82 unsigned long freq
, scale_cpu
;
83 struct em_cap_state
*cs
;
87 * In order to predict the capacity state, map the utilization of the
88 * most utilized CPU of the performance domain to a requested frequency,
91 cpu
= cpumask_first(to_cpumask(pd
->cpus
));
92 scale_cpu
= arch_scale_cpu_capacity(cpu
);
93 cs
= &pd
->table
[pd
->nr_cap_states
- 1];
94 freq
= map_util_freq(max_util
, cs
->frequency
, scale_cpu
);
97 * Find the lowest capacity state of the Energy Model above the
98 * requested frequency.
100 for (i
= 0; i
< pd
->nr_cap_states
; i
++) {
102 if (cs
->frequency
>= freq
)
107 * The capacity of a CPU in the domain at that capacity state (cs)
108 * can be computed as:
110 * cs->freq * scale_cpu
111 * cs->cap = -------------------- (1)
114 * So, ignoring the costs of idle states (which are not available in
115 * the EM), the energy consumed by this CPU at that capacity state is
118 * cs->power * cpu_util
119 * cpu_nrg = -------------------- (2)
122 * since 'cpu_util / cs->cap' represents its percentage of busy time.
124 * NOTE: Although the result of this computation actually is in
125 * units of power, it can be manipulated as an energy value
126 * over a scheduling period, since it is assumed to be
127 * constant during that interval.
129 * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product
132 * cs->power * cpu_max_freq cpu_util
133 * cpu_nrg = ------------------------ * --------- (3)
136 * The first term is static, and is stored in the em_cap_state struct
139 * Since all CPUs of the domain have the same micro-architecture, they
140 * share the same 'cs->cost', and the same CPU capacity. Hence, the
141 * total energy of the domain (which is the simple sum of the energy of
142 * all of its CPUs) can be factorized as:
144 * cs->cost * \Sum cpu_util
145 * pd_nrg = ------------------------ (4)
148 return cs
->cost
* sum_util
/ scale_cpu
;
152 * em_pd_nr_cap_states() - Get the number of capacity states of a perf. domain
153 * @pd : performance domain for which this must be done
155 * Return: the number of capacity states in the performance domain table
157 static inline int em_pd_nr_cap_states(struct em_perf_domain
*pd
)
159 return pd
->nr_cap_states
;
163 struct em_perf_domain
{};
164 struct em_data_callback
{};
165 #define EM_DATA_CB(_active_power_cb) { }
167 static inline int em_register_perf_domain(cpumask_t
*span
,
168 unsigned int nr_states
, struct em_data_callback
*cb
)
172 static inline struct em_perf_domain
*em_cpu_get(int cpu
)
176 static inline unsigned long em_pd_energy(struct em_perf_domain
*pd
,
177 unsigned long max_util
, unsigned long sum_util
)
181 static inline int em_pd_nr_cap_states(struct em_perf_domain
*pd
)