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/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  */
  21 struct 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  */
  44 struct 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
  72 struct 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
  97 struct em_perf_domain *em_cpu_get(int cpu);
  98 struct em_perf_domain *em_pd_get(struct device *dev);
  99 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
 100                                 struct em_data_callback *cb, cpumask_t *span,
 101                                 bool milliwatts);
 102 void 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  */
 120 static 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  */
 209 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd)
 210 {
 211         return pd->nr_perf_states;
 212 }
 213
 214 #else
 215 struct em_data_callback {};
 216 #define EM_DATA_CB(_active_power_cb) { }
 217
 218 static inline
 219 int 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 }
 225 static inline void em_dev_unregister_perf_domain(struct device *dev)
 226 {
 227 }
 228 static inline struct em_perf_domain *em_cpu_get(int cpu)
 229 {
 230         return NULL;
 231 }
 232 static inline struct em_perf_domain *em_pd_get(struct device *dev)
 233 {
 234         return NULL;
 235 }
 236 static 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 }
 242 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd)
 243 {
 244         return 0;
 245 }
 246 #endif
 247
 248 #endif