Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426/* SPDX-License-Identifier: GPL-2.0 */#ifndef _LINUX_ENERGY_MODEL_H#define _LINUX_ENERGY_MODEL_H#include <linux/cpumask.h>#include <linux/device.h>#include <linux/jump_label.h>#include <linux/kobject.h>#include <linux/kref.h>#include <linux/rcupdate.h>#include <linux/sched/cpufreq.h>#include <linux/sched/topology.h>#include <linux/types.h>
/** * struct em_perf_state - Performance state of a performance domain * @performance: CPU performance (capacity) at a given frequency * @frequency: The frequency in KHz, for consistency with CPUFreq * @power: The power consumed at this level (by 1 CPU or by a registered * device). It can be a total power: static and dynamic. * @cost: The cost coefficient associated with this level, used during * energy calculation. Equal to: 10 * power * max_frequency / frequency * @flags: see "em_perf_state flags" description below. */struct em_perf_state { unsigned long performance; unsigned long frequency; unsigned long power; unsigned long cost; unsigned long flags;};
/* * em_perf_state flags: * * EM_PERF_STATE_INEFFICIENT: The performance state is inefficient. There is * in this em_perf_domain, another performance state with a higher frequency * but a lower or equal power cost. Such inefficient states are ignored when * using em_pd_get_efficient_*() functions. */#define EM_PERF_STATE_INEFFICIENT BIT(0)
/** * struct em_perf_table - Performance states table * @rcu: RCU used for safe access and destruction * @kref: Reference counter to track the users * @state: List of performance states, in ascending order */struct em_perf_table { struct rcu_head rcu; struct kref kref; struct em_perf_state state[];};
/** * struct em_perf_domain - Performance domain * @em_table: Pointer to the runtime modifiable em_perf_table * @node: node in em_pd_list (in energy_model.c) * @id: A unique ID number for each performance domain * @nr_perf_states: Number of performance states * @min_perf_state: Minimum allowed Performance State index * @max_perf_state: Maximum allowed Performance State index * @flags: See "em_perf_domain flags" * @cpus: Cpumask covering the CPUs of the domain. It's here * for performance reasons to avoid potential cache * misses during energy calculations in the scheduler * and simplifies allocating/freeing that memory region. * * In case of CPU device, a "performance domain" represents a group of CPUs * whose performance is scaled together. All CPUs of a performance domain * must have the same micro-architecture. Performance domains often have * a 1-to-1 mapping with CPUFreq policies. In case of other devices the @cpus * field is unused. */struct em_perf_domain { struct em_perf_table __rcu *em_table; struct list_head node; int id; int nr_perf_states; int min_perf_state; int max_perf_state; unsigned long flags; unsigned long cpus[];};
/* * em_perf_domain flags: * * EM_PERF_DOMAIN_MICROWATTS: The power values are in micro-Watts or some * other scale. * * EM_PERF_DOMAIN_SKIP_INEFFICIENCIES: Skip inefficient states when estimating * energy consumption. * * EM_PERF_DOMAIN_ARTIFICIAL: The power values are artificial and might be * created by platform missing real power information */#define EM_PERF_DOMAIN_MICROWATTS BIT(0)#define EM_PERF_DOMAIN_SKIP_INEFFICIENCIES BIT(1)#define EM_PERF_DOMAIN_ARTIFICIAL BIT(2)
#define em_span_cpus(em) (to_cpumask((em)->cpus))#define em_is_artificial(em) ((em)->flags & EM_PERF_DOMAIN_ARTIFICIAL)
#ifdef CONFIG_ENERGY_MODEL/* * The max power value in micro-Watts. The limit of 64 Watts is set as * a safety net to not overflow multiplications on 32bit platforms. The * 32bit value limit for total Perf Domain power implies a limit of * maximum CPUs in such domain to 64. */#define EM_MAX_POWER (64000000) /* 64 Watts */
/* * To avoid possible energy estimation overflow on 32bit machines add * limits to number of CPUs in the Perf. Domain. * We are safe on 64bit machine, thus some big number. */#ifdef CONFIG_64BIT#define EM_MAX_NUM_CPUS 4096#else#define EM_MAX_NUM_CPUS 16#endif
struct em_data_callback { /** * active_power() - Provide power at the next performance state of * a device * @dev : Device for which we do this operation (can be a CPU) * @power : Active power at the performance state * (modified) * @freq : Frequency at the performance state in kHz * (modified) * * active_power() must find the lowest performance state of 'dev' above * 'freq' and update 'power' and 'freq' to the matching active power * and frequency. * * In case of CPUs, the power is the one of a single CPU in the domain, * expressed in micro-Watts or an abstract scale. It is expected to * fit in the [0, EM_MAX_POWER] range. * * Return 0 on success. */ int (*active_power)(struct device *dev, unsigned long *power, unsigned long *freq);
/** * get_cost() - Provide the cost at the given performance state of * a device * @dev : Device for which we do this operation (can be a CPU) * @freq : Frequency at the performance state in kHz * @cost : The cost value for the performance state * (modified) * * In case of CPUs, the cost is the one of a single CPU in the domain. * It is expected to fit in the [0, EM_MAX_POWER] range due to internal * usage in EAS calculation. * * Return 0 on success, or appropriate error value in case of failure. */ int (*get_cost)(struct device *dev, unsigned long freq, unsigned long *cost);};#define EM_SET_ACTIVE_POWER_CB(em_cb, cb) ((em_cb).active_power = cb)#define EM_ADV_DATA_CB(_active_power_cb, _cost_cb) \ { .active_power = _active_power_cb, \ .get_cost = _cost_cb }#define EM_DATA_CB(_active_power_cb) \ EM_ADV_DATA_CB(_active_power_cb, NULL)
struct em_perf_domain *em_cpu_get(int cpu);struct em_perf_domain *em_pd_get(struct device *dev);int em_dev_update_perf_domain(struct device *dev, struct em_perf_table *new_table);int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, const struct em_data_callback *cb, const cpumask_t *cpus, bool microwatts);int em_dev_register_pd_no_update(struct device *dev, unsigned int nr_states, const struct em_data_callback *cb, const cpumask_t *cpus, bool microwatts);void em_dev_unregister_perf_domain(struct device *dev);struct em_perf_table *em_table_alloc(struct em_perf_domain *pd);void em_table_free(struct em_perf_table *table);int em_dev_compute_costs(struct device *dev, struct em_perf_state *table, int nr_states);int em_dev_update_chip_binning(struct device *dev);int em_update_performance_limits(struct em_perf_domain *pd, unsigned long freq_min_khz, unsigned long freq_max_khz);void em_adjust_cpu_capacity(unsigned int cpu);void em_rebuild_sched_domains(void);
/** * em_pd_get_efficient_state() - Get an efficient performance state from the EM * @table: List of performance states, in ascending order * @pd: performance domain for which this must be done * @max_util: Max utilization to map with the EM * * It is called from the scheduler code quite frequently and as a consequence * doesn't implement any check. * * Return: An efficient performance state id, high enough to meet @max_util * requirement. */static inline intem_pd_get_efficient_state(struct em_perf_state *table, struct em_perf_domain *pd, unsigned long max_util){ unsigned long pd_flags = pd->flags; int min_ps = pd->min_perf_state; int max_ps = pd->max_perf_state; struct em_perf_state *ps; int i;
for (i = min_ps; i <= max_ps; i++) { ps = &table[i]; if (ps->performance >= max_util) { if (pd_flags & EM_PERF_DOMAIN_SKIP_INEFFICIENCIES && ps->flags & EM_PERF_STATE_INEFFICIENT) continue; return i; } }
return max_ps;}
/** * em_cpu_energy() - Estimates the energy consumed by the CPUs of a * performance domain * @pd : performance domain for which energy has to be estimated * @max_util : highest utilization among CPUs of the domain * @sum_util : sum of the utilization of all CPUs in the domain * @allowed_cpu_cap : maximum allowed CPU capacity for the @pd, which * might reflect reduced frequency (due to thermal) * * This function must be used only for CPU devices. There is no validation, * i.e. if the EM is a CPU type and has cpumask allocated. It is called from * the scheduler code quite frequently and that is why there is not checks. * * Return: the sum of the energy consumed by the CPUs of the domain assuming * a capacity state satisfying the max utilization of the domain. */static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, unsigned long max_util, unsigned long sum_util, unsigned long allowed_cpu_cap){ struct em_perf_table *em_table; struct em_perf_state *ps; int i;
lockdep_assert(rcu_read_lock_any_held());
if (!sum_util) return 0;
/* * In order to predict the performance state, map the utilization of * the most utilized CPU of the performance domain to a requested * performance, like schedutil. Take also into account that the real * performance might be set lower (due to thermal capping). Thus, clamp * max utilization to the allowed CPU capacity before calculating * effective performance. */ max_util = min(max_util, allowed_cpu_cap);
/* * Find the lowest performance state of the Energy Model above the * requested performance. */ em_table = rcu_dereference_all(pd->em_table); i = em_pd_get_efficient_state(em_table->state, pd, max_util); ps = &em_table->state[i];
/* * The performance (capacity) of a CPU in the domain at the performance * state (ps) can be computed as: * * ps->freq * scale_cpu * ps->performance = -------------------- (1) * cpu_max_freq * * So, ignoring the costs of idle states (which are not available in * the EM), the energy consumed by this CPU at that performance state * is estimated as: * * ps->power * cpu_util * cpu_nrg = -------------------- (2) * ps->performance * * since 'cpu_util / ps->performance' represents its percentage of busy * time. * * NOTE: Although the result of this computation actually is in * units of power, it can be manipulated as an energy value * over a scheduling period, since it is assumed to be * constant during that interval. * * By injecting (1) in (2), 'cpu_nrg' can be re-expressed as a product * of two terms: * * ps->power * cpu_max_freq * cpu_nrg = ------------------------ * cpu_util (3) * ps->freq * scale_cpu * * The first term is static, and is stored in the em_perf_state struct * as 'ps->cost'. * * Since all CPUs of the domain have the same micro-architecture, they * share the same 'ps->cost', and the same CPU capacity. Hence, the * total energy of the domain (which is the simple sum of the energy of * all of its CPUs) can be factorized as: * * pd_nrg = ps->cost * \Sum cpu_util (4) */ return ps->cost * sum_util;}
/** * em_pd_nr_perf_states() - Get the number of performance states of a perf. * domain * @pd : performance domain for which this must be done * * Return: the number of performance states in the performance domain table */static inline int em_pd_nr_perf_states(struct em_perf_domain *pd){ return pd->nr_perf_states;}
/** * em_perf_state_from_pd() - Get the performance states table of perf. * domain * @pd : performance domain for which this must be done * * To use this function the rcu_read_lock() should be hold. After the usage * of the performance states table is finished, the rcu_read_unlock() should * be called. * * Return: the pointer to performance states table of the performance domain */static inlinestruct em_perf_state *em_perf_state_from_pd(struct em_perf_domain *pd){ return rcu_dereference(pd->em_table)->state;}
#elsestruct em_data_callback {};#define EM_ADV_DATA_CB(_active_power_cb, _cost_cb) { }#define EM_DATA_CB(_active_power_cb) { }#define EM_SET_ACTIVE_POWER_CB(em_cb, cb) do { } while (0)
static inlineint em_dev_register_perf_domain(struct device *dev, unsigned int nr_states, const struct em_data_callback *cb, const cpumask_t *cpus, bool microwatts){ return -EINVAL;}static inlineint em_dev_register_pd_no_update(struct device *dev, unsigned int nr_states, const struct em_data_callback *cb, const cpumask_t *cpus, bool microwatts){ return -EINVAL;}static inline void em_dev_unregister_perf_domain(struct device *dev){}static inline struct em_perf_domain *em_cpu_get(int cpu){ return NULL;}static inline struct em_perf_domain *em_pd_get(struct device *dev){ return NULL;}static inline unsigned long em_cpu_energy(struct em_perf_domain *pd, unsigned long max_util, unsigned long sum_util, unsigned long allowed_cpu_cap){ return 0;}static inline int em_pd_nr_perf_states(struct em_perf_domain *pd){ return 0;}static inlinestruct em_perf_table *em_table_alloc(struct em_perf_domain *pd){ return NULL;}static inline void em_table_free(struct em_perf_table *table) {}static inlineint em_dev_update_perf_domain(struct device *dev, struct em_perf_table *new_table){ return -EINVAL;}static inlinestruct em_perf_state *em_perf_state_from_pd(struct em_perf_domain *pd){ return NULL;}static inlineint em_dev_compute_costs(struct device *dev, struct em_perf_state *table, int nr_states){ return -EINVAL;}static inline int em_dev_update_chip_binning(struct device *dev){ return -EINVAL;}static inlineint em_update_performance_limits(struct em_perf_domain *pd, unsigned long freq_min_khz, unsigned long freq_max_khz){ return -EINVAL;}static inline void em_adjust_cpu_capacity(unsigned int cpu) {}static inline void em_rebuild_sched_domains(void) {}#endif
#endif