[v5,0/8] inefficient OPPs

Hi all,

Here's the new version for the inefficient OPPs. This patch-set is based on the
following series from Viresh:

  [PATCH V3 0/9] Add callback to register with energy model
  https://lore.kernel.org/linux-arm-msm/cover.1628742634.git.viresh.kumar@linaro.org/

The main changes are:

 1. The EM inefficiencies reading is now done in the .register_em callback,
    introduced by the patch-set above.

 2. Inefficiencies will be skipped for all governors declaring
    CPUFREQ_GOV_DYNAMIC_SWITCHING, no matter the relation.

A bit of context:

We (Power team in Arm) are working with an experimental kernel for the
Google's Pixel4 to evaluate and improve the current mainline performance
and energy consumption on a real life device with Android.

The SD855 SoC found in this phone has several OPPs that are inefficient.
I.e. despite a lower frequency, they have a greater cost. (That cost being
fmax * OPP power / OPP freq). This issue is twofold. First of course,
running a specific workload at an inefficient OPP is counterproductive
since it wastes wasting energy. But also, inefficient OPPs make a
performance domain less appealing for task placement than it really is.

We evaluated the change presented here by running 30 iterations of Android
PCMark "Work 2.0 Performance". While we did not see any statistically
significant performance impact, this change allowed to drastically improve
the idle time residency.


                           |   Running   |  WFI [1]  |    Idle   |
   ------------------------+-------------+-----------+-----------+
   Little cluster (4 CPUs) |    -0.35%   |   +0.35%  |   +0.79%  |
   ------------------------+-------------+-----------+-----------+
   Medium cluster (3 CPUs) |    -6.3%    |    -18%   |    +12%   |
   ------------------------+-------------+-----------+-----------+
   Big cluster    (1 CPU)  |    -6.4%    |    -6.5%  |    +2.8%  |
   ------------------------+-------------+-----------+-----------+

On the SD855, the inefficient OPPs are found on the little cluster. By
removing them from the Energy Model, we make the most efficient CPUs more
appealing for task placement, helping to reduce the running time for the
medium and big CPUs. Increasing idle time is crucial for this platform due
to the substantial energy cost differences among the clusters. Also,
despite not appearing in the statistics (the idle driver used here doesn't
report it), we can speculate that we also improve the cluster idle time.

[1] WFI: Wait for interrupt.

Changelog since v4:
  - Remove CPUFREQ_RELATION_E.
  - Skip inefficient OPPs for all governors with CPUFREQ_GOV_DYNAMIC_SWITCHING
  - Remove CPUFREQ_READ_ENERGY_MODEL in favor of the register_em callback.

Changelog since v3:
  - New freq-table relation CPUFREQ_RELATION_E.
  - New CPUFreq driver flag CPUFREQ_READ_ENERGY_MODEL.
  - EM flag to skip or not inefficiencies (driven by CPUFreq).
  - Fix infinite loop in set_freq_table_efficiencies().

Changelog since v2:
  - Add separated support for inefficiencies into CPUFreq.
  - Collect Reviewed-by for the first patch.

Changelog since v1:
  - Remove the Look-up table as the numbers weren't strong enough to

Vincent Donnefort (8):
  PM / EM: Fix inefficient states detection
  PM / EM: Mark inefficient states
  PM / EM: Extend em_perf_domain with a flag field
  PM / EM: Allow skipping inefficient states
  cpufreq: Add an interface to mark inefficient frequencies
  cpufreq: Skip inefficient frequencies
  cpufreq: Read inefficiencies from EM
  cpufreq: scmi: Read inefficiencies from EM

 drivers/cpufreq/cpufreq.c      | 13 ++++++
 drivers/cpufreq/freq_table.c   | 46 +++++++++++++++++++++
 drivers/cpufreq/scmi-cpufreq.c |  7 ++--
 include/linux/cpufreq.h        | 90 +++++++++++++++++++++++++++++++++++++++---
 include/linux/energy_model.h   | 68 ++++++++++++++++++++++++++-----
 kernel/power/energy_model.c    | 46 ++++++++++++---------
 6 files changed, 234 insertions(+), 36 deletions(-)

On 26-08-21, 09:35, Vincent Donnefort wrote:
> The Energy Model has a 1:1 mapping between OPPs and performance states
> (em_perf_state). If a CPUFreq driver registers an Energy Model,
> inefficiencies found by the latter can be applied to CPUFreq.
> 
> Signed-off-by: Vincent Donnefort <vincent.donnefort@arm.com>
> 
> diff --git a/drivers/cpufreq/scmi-cpufreq.c b/drivers/cpufreq/scmi-cpufreq.c
> index 1e0cd4d165f0..f4fd634d2ecd 100644
> --- a/drivers/cpufreq/scmi-cpufreq.c
> +++ b/drivers/cpufreq/scmi-cpufreq.c
> @@ -250,6 +250,7 @@ static void scmi_cpufreq_register_em(struct cpufreq_policy *policy)
>  {
>  	struct em_data_callback em_cb = EM_DATA_CB(scmi_get_cpu_power);
>  	bool power_scale_mw = perf_ops->power_scale_mw_get(ph);
> +	struct device *cpu_dev = get_cpu_device(policy->cpu);
>  	struct scmi_data *priv = policy->driver_data;
>  
>  	/*
> @@ -262,9 +263,9 @@ static void scmi_cpufreq_register_em(struct cpufreq_policy *policy)
>  	if (!priv->nr_opp)
>  		return;
>  
> -	em_dev_register_perf_domain(get_cpu_device(policy->cpu), priv->nr_opp,
> -				    &em_cb, priv->opp_shared_cpus,
> -				    power_scale_mw);
> +	em_dev_register_perf_domain(cpu_dev, priv->nr_opp, &em_cb,
> +				    priv->opp_shared_cpus, power_scale_mw);
> +	cpufreq_read_inefficiencies_from_em(policy, em_pd_get(cpu_dev));
>  }
>  
>  static struct cpufreq_driver scmi_cpufreq_driver = {

Same here.