6:44 a.m.
Hi Vincent,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on tip/sched/core]
[also build test WARNING on next-20220112]
[cannot apply to rafael-pm/linux-next rafael-pm/thermal v5.16]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url:
https://github.com/0day-ci/linux/commits/Vincent-Donnefort/feec-energy-ma...
base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git
82762d2af31a60081162890983a83499c9c7dd74
config: hexagon-randconfig-r045-20220112
(https://download.01.org/0day-ci/archive/20220113/202201130354.S8Z1unuB-lk...)
compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project
244dd2913a43a200f5a6544d424cdc37b771028b)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O
~/bin/make.cross
chmod +x ~/bin/make.cross
#
https://github.com/0day-ci/linux/commit/ce70047d014b32af0102fca5681c1e8ae...
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review
Vincent-Donnefort/feec-energy-margin-removal/20220113-002104
git checkout ce70047d014b32af0102fca5681c1e8aebc4b7ae
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir
ARCH=hexagon SHELL=/bin/bash kernel/sched/
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp(a)intel.com>
All warnings (new ones prefixed by >>):
> kernel/sched/fair.c:6738:4: warning: variable 'pd_cap' is
uninitialized when used here [-Wuninitialized]
pd_cap +=
cpu_thermal_cap;
^~~~~~
kernel/sched/fair.c:6693:58: note: initialize the variable 'pd_cap' to silence
this warning
unsigned long busy_time, tsk_busy_time, max_util, pd_cap;
^
= 0
1 warning generated.
vim +/pd_cap +6738 kernel/sched/fair.c
6649
6650 /*
6651 * find_energy_efficient_cpu(): Find most energy-efficient target CPU for the
6652 * waking task. find_energy_efficient_cpu() looks for the CPU with maximum
6653 * spare capacity in each performance domain and uses it as a potential
6654 * candidate to execute the task. Then, it uses the Energy Model to figure
6655 * out which of the CPU candidates is the most energy-efficient.
6656 *
6657 * The rationale for this heuristic is as follows. In a performance domain,
6658 * all the most energy efficient CPU candidates (according to the Energy
6659 * Model) are those for which we'll request a low frequency. When there are
6660 * several CPUs for which the frequency request will be the same, we don't
6661 * have enough data to break the tie between them, because the Energy Model
6662 * only includes active power costs. With this model, if we assume that
6663 * frequency requests follow utilization (e.g. using schedutil), the CPU with
6664 * the maximum spare capacity in a performance domain is guaranteed to be among
6665 * the best candidates of the performance domain.
6666 *
6667 * In practice, it could be preferable from an energy standpoint to pack
6668 * small tasks on a CPU in order to let other CPUs go in deeper idle states,
6669 * but that could also hurt our chances to go cluster idle, and we have no
6670 * ways to tell with the current Energy Model if this is actually a good
6671 * idea or not. So, find_energy_efficient_cpu() basically favors
6672 * cluster-packing, and spreading inside a cluster. That should at least be
6673 * a good thing for latency, and this is consistent with the idea that most
6674 * of the energy savings of EAS come from the asymmetry of the system, and
6675 * not so much from breaking the tie between identical CPUs. That's also the
6676 * reason why EAS is enabled in the topology code only for systems where
6677 * SD_ASYM_CPUCAPACITY is set.
6678 *
6679 * NOTE: Forkees are not accepted in the energy-aware wake-up path because
6680 * they don't have any useful utilization data yet and it's not possible
to
6681 * forecast their impact on energy consumption. Consequently, they will be
6682 * placed by find_idlest_cpu() on the least loaded CPU, which might turn out
6683 * to be energy-inefficient in some use-cases. The alternative would be to
6684 * bias new tasks towards specific types of CPUs first, or to try to infer
6685 * their util_avg from the parent task, but those heuristics could hurt
6686 * other use-cases too. So, until someone finds a better way to solve this,
6687 * let's keep things simple by re-using the existing slow path.
6688 */
6689 static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu)
6690 {
6691 struct cpumask *cpus = this_cpu_cpumask_var_ptr(select_rq_mask);
6692 unsigned long prev_delta = ULONG_MAX, best_delta = ULONG_MAX;
6693 unsigned long busy_time, tsk_busy_time, max_util, pd_cap;
6694 struct root_domain *rd = cpu_rq(smp_processor_id())->rd;
6695 int cpu, best_energy_cpu = prev_cpu, target = -1;
6696 unsigned long cpu_cap, cpu_thermal_cap, util;
6697 unsigned long base_energy = 0;
6698 struct sched_domain *sd;
6699 struct perf_domain *pd;
6700
6701 rcu_read_lock();
6702 pd = rcu_dereference(rd->pd);
6703 if (!pd || READ_ONCE(rd->overutilized))
6704 goto unlock;
6705
6706 /*
6707 * Energy-aware wake-up happens on the lowest sched_domain starting
6708 * from sd_asym_cpucapacity spanning over this_cpu and prev_cpu.
6709 */
6710 sd = rcu_dereference(*this_cpu_ptr(&sd_asym_cpucapacity));
6711 while (sd && !cpumask_test_cpu(prev_cpu, sched_domain_span(sd)))
6712 sd = sd->parent;
6713 if (!sd)
6714 goto unlock;
6715
6716 target = prev_cpu;
6717
6718 sync_entity_load_avg(&p->se);
6719 if (!task_util_est(p))
6720 goto unlock;
6721
6722 tsk_busy_time = get_task_busy_time(p, prev_cpu);
6723
6724 for (; pd; pd = pd->next) {
6725 unsigned long cur_delta, spare_cap, max_spare_cap = 0;
6726 bool compute_prev_delta = false;
6727 unsigned long base_energy_pd;
6728 int max_spare_cap_cpu = -1;
6729
6730 cpumask_and(cpus, perf_domain_span(pd), cpu_online_mask);
6731
6732 /* Account thermal pressure for the energy estimation */
6733 cpu = cpumask_first(cpus);
6734 cpu_thermal_cap = arch_scale_cpu_capacity(cpu);
6735 cpu_thermal_cap -= arch_scale_thermal_pressure(cpu);
6736
6737 for_each_cpu(cpu, cpus) {
6738 pd_cap += cpu_thermal_cap;
6739
6740 if (!cpumask_test_cpu(cpu, sched_domain_span(sd)))
6741 continue;
6742
6743 if (!cpumask_test_cpu(cpu, p->cpus_ptr))
6744 continue;
6745
6746 util = cpu_util_next(cpu, p, cpu);
6747 cpu_cap = capacity_of(cpu);
6748 spare_cap = cpu_cap;
6749 lsub_positive(&spare_cap, util);
6750
6751 /*
6752 * Skip CPUs that cannot satisfy the capacity request.
6753 * IOW, placing the task there would make the CPU
6754 * overutilized. Take uclamp into account to see how
6755 * much capacity we can get out of the CPU; this is
6756 * aligned with sched_cpu_util().
6757 */
6758 util = uclamp_rq_util_with(cpu_rq(cpu), util, p);
6759 if (!fits_capacity(util, cpu_cap))
6760 continue;
6761
6762 if (cpu == prev_cpu) {
6763 /* Always use prev_cpu as a candidate. */
6764 compute_prev_delta = true;
6765 } else if (spare_cap > max_spare_cap) {
6766 /*
6767 * Find the CPU with the maximum spare capacity
6768 * in the performance domain.
6769 */
6770 max_spare_cap = spare_cap;
6771 max_spare_cap_cpu = cpu;
6772 }
6773 }
6774
6775 if (max_spare_cap_cpu < 0 && !compute_prev_delta)
6776 continue;
6777
6778 /* Compute the 'base' energy of the pd, without @p */
6779 busy_time = get_pd_busy_time(p, cpus, pd_cap);
6780 max_util = get_pd_max_util(p, -1, cpus, cpu_thermal_cap);
6781 base_energy_pd = compute_energy(pd, max_util, busy_time,
6782 cpu_thermal_cap);
6783 base_energy += base_energy_pd;
6784
6785 /* Take task into account for the next energy computations */
6786 busy_time = min(pd_cap, busy_time + tsk_busy_time);
6787
6788 /* Evaluate the energy impact of using prev_cpu. */
6789 if (compute_prev_delta) {
6790 max_util = get_pd_max_util(p, prev_cpu, cpus,
6791 cpu_thermal_cap);
6792 prev_delta = compute_energy(pd, max_util, busy_time,
6793 cpu_thermal_cap);
6794 if (prev_delta < base_energy_pd)
6795 goto unlock;
6796 prev_delta -= base_energy_pd;
6797 best_delta = min(best_delta, prev_delta);
6798 }
6799
6800 /* Evaluate the energy impact of using max_spare_cap_cpu. */
6801 if (max_spare_cap_cpu >= 0) {
6802 max_util = get_pd_max_util(p, max_spare_cap_cpu, cpus,
6803 cpu_thermal_cap);
6804 cur_delta = compute_energy(pd, max_util, busy_time,
6805 cpu_thermal_cap);
6806 if (cur_delta < base_energy_pd)
6807 goto unlock;
6808 cur_delta -= base_energy_pd;
6809 if (cur_delta < best_delta) {
6810 best_delta = cur_delta;
6811 best_energy_cpu = max_spare_cap_cpu;
6812 }
6813 }
6814 }
6815 rcu_read_unlock();
6816
6817 /*
6818 * Pick the best CPU if prev_cpu cannot be used, or if it saves at
6819 * least 6% of the energy used by prev_cpu.
6820 */
6821 if ((prev_delta == ULONG_MAX) ||
6822 (prev_delta - best_delta) > ((prev_delta + base_energy) >> 4))
6823 target = best_energy_cpu;
6824
6825 return target;
6826
6827 unlock:
6828 rcu_read_unlock();
6829
6830 return target;
6831 }
6832
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org