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  * @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 #define EM_SET_ACTIVE_POWER_CB(em_cb, cb) ((em_cb).active_power = cb)
 120
 121 struct em_perf_domain *em_cpu_get(int cpu);
 122 struct em_perf_domain *em_pd_get(struct device *dev);
 123 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
 124                                 struct em_data_callback *cb, cpumask_t *span,
 125                                 bool milliwatts);
 126 void em_dev_unregister_perf_domain(struct device *dev);
 127
 128 /**
 129  * em_pd_get_efficient_state() - Get an efficient performance state from the EM
 130  * @pd   : Performance domain for which we want an efficient frequency
 131  * @freq : Frequency to map with the EM
 132  *
 133  * It is called from the scheduler code quite frequently and as a consequence
 134  * doesn't implement any check.
 135  *
 136  * Return: An efficient performance state, high enough to meet @freq
 137  * requirement.
 138  */
 139 static inline
 140 struct em_perf_state *em_pd_get_efficient_state(struct em_perf_domain *pd,
 141                                                 unsigned long freq)
 142 {
 143         struct em_perf_state *ps;
 144         int i;
 145
 146         for (i = 0; i < pd->nr_perf_states; i++) {
 147                 ps = &pd->table[i];
 148                 if (ps->frequency >= freq) {
 149                         if (pd->flags & EM_PERF_DOMAIN_SKIP_INEFFICIENCIES &&
 150                             ps->flags & EM_PERF_STATE_INEFFICIENT)
 151                                 continue;
 152                         break;
 153                 }
 154         }
 155
 156         return ps;
 157 }
 158
 159 /**
 160  * em_cpu_energy() - Estimates the energy consumed by the CPUs of a
 161  *              performance domain
 162  * @pd          : performance domain for which energy has to be estimated
 163  * @max_util    : highest utilization among CPUs of the domain
 164  * @sum_util    : sum of the utilization of all CPUs in the domain
 165  * @allowed_cpu_cap     : maximum allowed CPU capacity for the @pd, which
 166  *                        might reflect reduced frequency (due to thermal)
 167  *
 168  * This function must be used only for CPU devices. There is no validation,
 169  * i.e. if the EM is a CPU type and has cpumask allocated. It is called from
 170  * the scheduler code quite frequently and that is why there is not checks.
 171  *
 172  * Return: the sum of the energy consumed by the CPUs of the domain assuming
 173  * a capacity state satisfying the max utilization of the domain.
 174  */
 175 static inline unsigned long em_cpu_energy(struct em_perf_domain *pd,
 176                                 unsigned long max_util, unsigned long sum_util,
 177                                 unsigned long allowed_cpu_cap)
 178 {
 179         unsigned long freq, scale_cpu;
 180         struct em_perf_state *ps;
 181         int cpu;
 182
 183         if (!sum_util)
 184                 return 0;
 185
 186         /*
 187          * In order to predict the performance state, map the utilization of
 188          * the most utilized CPU of the performance domain to a requested
 189          * frequency, like schedutil. Take also into account that the real
 190          * frequency might be set lower (due to thermal capping). Thus, clamp
 191          * max utilization to the allowed CPU capacity before calculating
 192          * effective frequency.
 193          */
 194         cpu = cpumask_first(to_cpumask(pd->cpus));
 195         scale_cpu = arch_scale_cpu_capacity(cpu);
 196         ps = &pd->table[pd->nr_perf_states - 1];
 197
 198         max_util = map_util_perf(max_util);
 199         max_util = min(max_util, allowed_cpu_cap);
 200         freq = map_util_freq(max_util, ps->frequency, scale_cpu);
 201
 202         /*
 203          * Find the lowest performance state of the Energy Model above the
 204          * requested frequency.
 205          */
 206         ps = em_pd_get_efficient_state(pd, freq);
 207
 208         /*
 209          * The capacity of a CPU in the domain at the performance state (ps)
 210          * can be computed as:
 211          *
 212          *             ps->freq * scale_cpu
 213          *   ps->cap = --------------------                          (1)
 214          *                 cpu_max_freq
 215          *
 216          * So, ignoring the costs of idle states (which are not available in
 217          * the EM), the energy consumed by this CPU at that performance state
 218          * is estimated as:
 219          *
 220          *             ps->power * cpu_util
 221          *   cpu_nrg = --------------------                          (2)
 222          *                   ps->cap
 223          *
 224          * since 'cpu_util / ps->cap' represents its percentage of busy time.
 225          *
 226          *   NOTE: Although the result of this computation actually is in
 227          *         units of power, it can be manipulated as an energy value
 228          *         over a scheduling period, since it is assumed to be
 229          *         constant during that interval.
 230          *
 231          * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product
 232          * of two terms:
 233          *
 234          *             ps->power * cpu_max_freq   cpu_util
 235          *   cpu_nrg = ------------------------ * ---------          (3)
 236          *                    ps->freq            scale_cpu
 237          *
 238          * The first term is static, and is stored in the em_perf_state struct
 239          * as 'ps->cost'.
 240          *
 241          * Since all CPUs of the domain have the same micro-architecture, they
 242          * share the same 'ps->cost', and the same CPU capacity. Hence, the
 243          * total energy of the domain (which is the simple sum of the energy of
 244          * all of its CPUs) can be factorized as:
 245          *
 246          *            ps->cost * \Sum cpu_util
 247          *   pd_nrg = ------------------------                       (4)
 248          *                  scale_cpu
 249          */
 250         return ps->cost * sum_util / scale_cpu;
 251 }
 252
 253 /**
 254  * em_pd_nr_perf_states() - Get the number of performance states of a perf.
 255  *                              domain
 256  * @pd          : performance domain for which this must be done
 257  *
 258  * Return: the number of performance states in the performance domain table
 259  */
 260 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd)
 261 {
 262         return pd->nr_perf_states;
 263 }
 264
 265 #else
 266 struct em_data_callback {};
 267 #define EM_DATA_CB(_active_power_cb) { }
 268 #define EM_SET_ACTIVE_POWER_CB(em_cb, cb) do { } while (0)
 269
 270 static inline
 271 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
 272                                 struct em_data_callback *cb, cpumask_t *span,
 273                                 bool milliwatts)
 274 {
 275         return -EINVAL;
 276 }
 277 static inline void em_dev_unregister_perf_domain(struct device *dev)
 278 {
 279 }
 280 static inline struct em_perf_domain *em_cpu_get(int cpu)
 281 {
 282         return NULL;
 283 }
 284 static inline struct em_perf_domain *em_pd_get(struct device *dev)
 285 {
 286         return NULL;
 287 }
 288 static inline unsigned long em_cpu_energy(struct em_perf_domain *pd,
 289                         unsigned long max_util, unsigned long sum_util,
 290                         unsigned long allowed_cpu_cap)
 291 {
 292         return 0;
 293 }
 294 static inline int em_pd_nr_perf_states(struct em_perf_domain *pd)
 295 {
 296         return 0;
 297 }
 298 #endif
 299
 300 #endif