Re: [PATCH v2] cpufreq: powernv: Replacing pstate_id with frequency table index

[Akshay Adiga <akshay.adiga@linux.vnet.ibm.com>]

On 06/30/2016 11:53 AM, Akshay Adiga wrote:
> Refactoring code to use frequency table index instead of pstate_id.
> This abstraction will make the code independent of the pstate values.
>
> - No functional changes
> - The highest frequency is at frequency table index 0 and the frequency
>    decreases as the index increases.
> - Macros pstates_to_idx() and idx_to_pstate() can be used for conversion
>    between pstate_id and index.
> - powernv_pstate_info now contains frequency table index to min, max and
>    nominal frequency (instead of pstate_ids)
> - global_pstate_info new stores index values instead pstate ids.
> - variables renamed as *_idx which now store index instead of pstate
>
> Signed-off-by: Akshay Adiga <akshay.adiga@linux.vnet.ibm.com>
> Reviewed-by: Gautham R. Shenoy <ego@linux.vnet.ibm.com>
> ---
> Changes from v1:
>    - changed macro names from get_pstate()/ get_index() to
> idx_to_pstate()/ pstate_to_idx()
>    - Renamed variables that store index instead of pstate_id to *_idx
>    - Retained previous printk's
>
> v1 : http://marc.info/?l=linux-pm&m=146677701501225&w=1
>
>   drivers/cpufreq/powernv-cpufreq.c | 177 ++++++++++++++++++++++----------------
>   1 file changed, 102 insertions(+), 75 deletions(-)
>
> diff --git a/drivers/cpufreq/powernv-cpufreq.c b/drivers/cpufreq/powernv-cpufreq.c
> index b29c5c2..72c91d8 100644
> --- a/drivers/cpufreq/powernv-cpufreq.c
> +++ b/drivers/cpufreq/powernv-cpufreq.c
> @@ -64,12 +64,14 @@
>   /**
>    * struct global_pstate_info -	Per policy data structure to maintain history of
>    *				global pstates
> - * @highest_lpstate:		The local pstate from which we are ramping down
> + * @highest_lpstate_idx:	The local pstate index from which we are
> + *				ramping down
>    * @elapsed_time:		Time in ms spent in ramping down from
> - *				highest_lpstate
> + *				highest_lpstate_idx
>    * @last_sampled_time:		Time from boot in ms when global pstates were
>    *				last set
> - * @last_lpstate,last_gpstate:	Last set values for local and global pstates
> + * @last_lpstate_idx,		Last set value of local pstate and global
> + * last_gpstate_idx		pstate in terms of cpufreq table index
>    * @timer:			Is used for ramping down if cpu goes idle for
>    *				a long time with global pstate held high
>    * @gpstate_lock:		A spinlock to maintain synchronization between
> @@ -77,11 +79,11 @@
>    *				governer's target_index calls
>    */
>   struct global_pstate_info {
> -	int highest_lpstate;
> +	int highest_lpstate_idx;
>   	unsigned int elapsed_time;
>   	unsigned int last_sampled_time;
> -	int last_lpstate;
> -	int last_gpstate;
> +	int last_lpstate_idx;
> +	int last_gpstate_idx;
>   	spinlock_t gpstate_lock;
>   	struct timer_list timer;
>   };
> @@ -124,29 +126,47 @@ static int nr_chips;
>   static DEFINE_PER_CPU(struct chip *, chip_info);
>   
>   /*
> - * Note: The set of pstates consists of contiguous integers, the
> - * smallest of which is indicated by powernv_pstate_info.min, the
> - * largest of which is indicated by powernv_pstate_info.max.
> + * Note:
> + * The set of pstates consists of contiguous integers.
> + * powernv_pstate_info stores the index of the frequency table for
> + * max, min and nominal frequencies. It also stores number of
> + * available frequencies.
>    *
> - * The nominal pstate is the highest non-turbo pstate in this
> - * platform. This is indicated by powernv_pstate_info.nominal.
> + * powernv_pstate_info.nominal indicates the index to the highest
> + * non-turbo frequency.
>    */
>   static struct powernv_pstate_info {
> -	int min;
> -	int max;
> -	int nominal;
> -	int nr_pstates;
> +	unsigned int min;
> +	unsigned int max;
> +	unsigned int nominal;
> +	unsigned int nr_pstates;
>   } powernv_pstate_info;
>   
> +/* Use following macros for conversions between pstate_id and index */
> +static inline int idx_to_pstate(unsigned int i)
> +{
> +	return powernv_freqs[i].driver_data;
> +}
> +
> +static inline unsigned int pstate_to_idx(int pstate)
> +{
> +	/*
> +	 * abs() is deliberately used so that is works with
> +	 * both monotonically increasing and decreasing
> +	 * pstate values
> +	 */
> +	return abs(pstate - idx_to_pstate(powernv_pstate_info.max));
> +}
> +
>   static inline void reset_gpstates(struct cpufreq_policy *policy)
>   {
>   	struct global_pstate_info *gpstates = policy->driver_data;
>   
> -	gpstates->highest_lpstate = 0;
> +	gpstates->highest_lpstate_idx = 0;
>   	gpstates->elapsed_time = 0;
>   	gpstates->last_sampled_time = 0;
> -	gpstates->last_lpstate = 0;
> -	gpstates->last_gpstate = 0;
> +	gpstates->last_lpstate_idx = 0;
> +	gpstates->last_gpstate_idx = 0;
>   }
>   
>   /*
> @@ -156,9 +176,10 @@ static inline void reset_gpstates(struct cpufreq_policy *policy)
>   static int init_powernv_pstates(void)
>   {
>   	struct device_node *power_mgt;
> -	int i, pstate_min, pstate_max, pstate_nominal, nr_pstates = 0;
> +	int i, nr_pstates = 0;
>   	const __be32 *pstate_ids, *pstate_freqs;
>   	u32 len_ids, len_freqs;
> +	u32 pstate_min, pstate_max, pstate_nominal;
>   
>   	power_mgt = of_find_node_by_path("/ibm,opal/power-mgt");
>   	if (!power_mgt) {
> @@ -208,6 +229,7 @@ static int init_powernv_pstates(void)
>   		return -ENODEV;
>   	}
>   
> +	powernv_pstate_info.nr_pstates = nr_pstates;
>   	pr_debug("NR PStates %d\n", nr_pstates);
>   	for (i = 0; i < nr_pstates; i++) {
>   		u32 id = be32_to_cpu(pstate_ids[i]);
> @@ -216,15 +238,17 @@ static int init_powernv_pstates(void)
>   		pr_debug("PState id %d freq %d MHz\n", id, freq);
>   		powernv_freqs[i].frequency = freq * 1000; /* kHz */
>   		powernv_freqs[i].driver_data = id;
> +
> +		if (id == pstate_max)
> +			powernv_pstate_info.max = i;
> +		else if (id == pstate_nominal)
> +			powernv_pstate_info.nominal = i;
> +		else if (id == pstate_min)
> +			powernv_pstate_info.min = i;
>   	}
> +
>   	/* End of list marker entry */
>   	powernv_freqs[i].frequency = CPUFREQ_TABLE_END;
> -
> -	powernv_pstate_info.min = pstate_min;
> -	powernv_pstate_info.max = pstate_max;
> -	powernv_pstate_info.nominal = pstate_nominal;
> -	powernv_pstate_info.nr_pstates = nr_pstates;
> -
>   	return 0;
>   }
>   
> @@ -233,12 +257,12 @@ static unsigned int pstate_id_to_freq(int pstate_id)
>   {
>   	int i;
>   
> -	i = powernv_pstate_info.max - pstate_id;
> +	i = pstate_to_idx(pstate_id);
>   	if (i >= powernv_pstate_info.nr_pstates || i < 0) {
>   		pr_warn("PState id %d outside of PState table, "
>   			"reporting nominal id %d instead\n",
> -			pstate_id, powernv_pstate_info.nominal);
> -		i = powernv_pstate_info.max - powernv_pstate_info.nominal;
> +			pstate_id, idx_to_pstate(powernv_pstate_info.nominal));
> +		i = powernv_pstate_info.nominal;
>   	}
>   
>   	return powernv_freqs[i].frequency;
> @@ -252,7 +276,7 @@ static ssize_t cpuinfo_nominal_freq_show(struct cpufreq_policy *policy,
>   					char *buf)
>   {
>   	return sprintf(buf, "%u\n",
> -		pstate_id_to_freq(powernv_pstate_info.nominal));
> +		powernv_freqs[powernv_pstate_info.nominal].frequency);
>   }
>   
>   struct freq_attr cpufreq_freq_attr_cpuinfo_nominal_freq =
> @@ -426,7 +450,7 @@ static void set_pstate(void *data)
>    */
>   static inline unsigned int get_nominal_index(void)
>   {
> -	return powernv_pstate_info.max - powernv_pstate_info.nominal;
> +	return powernv_pstate_info.nominal;
>   }
>   
>   static void powernv_cpufreq_throttle_check(void *data)
> @@ -435,20 +459,22 @@ static void powernv_cpufreq_throttle_check(void *data)
>   	unsigned int cpu = smp_processor_id();
>   	unsigned long pmsr;
>   	int pmsr_pmax;
> +	unsigned int pmsr_pmax_idx;
>   
>   	pmsr = get_pmspr(SPRN_PMSR);
>   	chip = this_cpu_read(chip_info);
>   
>   	/* Check for Pmax Capping */
>   	pmsr_pmax = (s8)PMSR_MAX(pmsr);
> -	if (pmsr_pmax != powernv_pstate_info.max) {
> +	pmsr_pmax_idx = pstate_to_idx(pmsr_pmax);
> +	if (pmsr_pmax_idx != powernv_pstate_info.max) {
>   		if (chip->throttled)
>   			goto next;
>   		chip->throttled = true;
> -		if (pmsr_pmax < powernv_pstate_info.nominal) {
> -			pr_warn_once("CPU %d on Chip %u has Pmax reduced below nominal frequency (%d < %d)\n",
> +		if (pmsr_pmax_idx > powernv_pstate_info.nominal) {
> +			pr_warn_once("CPU %d on Chip %u has Pmax(%d) reduced below nominal frequency(%d)\n",
>   				     cpu, chip->id, pmsr_pmax,
> -				     powernv_pstate_info.nominal);
> +				     idx_to_pstate(powernv_pstate_info.nominal));
>   			chip->throttle_sub_turbo++;
>   		} else {
>   			chip->throttle_turbo++;
> @@ -484,34 +510,35 @@ next:
>   
>   /**
>    * calc_global_pstate - Calculate global pstate
> - * @elapsed_time:	Elapsed time in milliseconds
> - * @local_pstate:	New local pstate
> - * @highest_lpstate:	pstate from which its ramping down
> + * @elapsed_time:		Elapsed time in milliseconds
> + * @local_pstate_idx:		New local pstate
> + * @highest_lpstate_idx:	pstate from which its ramping down
>    *
>    * Finds the appropriate global pstate based on the pstate from which its
>    * ramping down and the time elapsed in ramping down. It follows a quadratic
>    * equation which ensures that it reaches ramping down to pmin in 5sec.
>    */
>   static inline int calc_global_pstate(unsigned int elapsed_time,
> -				     int highest_lpstate, int local_pstate)
> +				     int highest_lpstate_idx,
> +				     int local_pstate_idx)
>   {
> -	int pstate_diff;
> +	int index_diff;
>   
>   	/*
>   	 * Using ramp_down_percent we get the percentage of rampdown
>   	 * that we are expecting to be dropping. Difference between
> -	 * highest_lpstate and powernv_pstate_info.min will give a absolute
> +	 * highest_lpstate_idx and powernv_pstate_info.min will give a absolute
>   	 * number of how many pstates we will drop eventually by the end of
>   	 * 5 seconds, then just scale it get the number pstates to be dropped.
>   	 */
> -	pstate_diff =  ((int)ramp_down_percent(elapsed_time) *
> -			(highest_lpstate - powernv_pstate_info.min)) / 100;
> +	index_diff =  ((int)ramp_down_percent(elapsed_time) *
> +			(powernv_pstate_info.min - highest_lpstate_idx)) / 100;
>   
>   	/* Ensure that global pstate is >= to local pstate */
> -	if (highest_lpstate - pstate_diff < local_pstate)
> -		return local_pstate;
> +	if (highest_lpstate_idx + index_diff >= local_pstate_idx)
> +		return local_pstate_idx;
>   	else
> -		return highest_lpstate - pstate_diff;
> +		return highest_lpstate_idx + index_diff;
>   }
>   
>   static inline void  queue_gpstate_timer(struct global_pstate_info *gpstates)
> @@ -547,7 +574,7 @@ void gpstate_timer_handler(unsigned long data)
>   {
>   	struct cpufreq_policy *policy = (struct cpufreq_policy *)data;
>   	struct global_pstate_info *gpstates = policy->driver_data;
> -	int gpstate_id;
> +	int gpstate_idx;
>   	unsigned int time_diff = jiffies_to_msecs(jiffies)
>   					- gpstates->last_sampled_time;
>   	struct powernv_smp_call_data freq_data;
> @@ -557,29 +584,29 @@ void gpstate_timer_handler(unsigned long data)
>   
>   	gpstates->last_sampled_time += time_diff;
>   	gpstates->elapsed_time += time_diff;
> -	freq_data.pstate_id = gpstates->last_lpstate;
> +	freq_data.pstate_id = idx_to_pstate(gpstates->last_lpstate_idx);
>   
> -	if ((gpstates->last_gpstate == freq_data.pstate_id) ||
> +	if ((gpstates->last_gpstate_idx == gpstates->last_lpstate_idx) ||
>   	    (gpstates->elapsed_time > MAX_RAMP_DOWN_TIME)) {
> -		gpstate_id = freq_data.pstate_id;
> +		gpstate_idx = pstate_to_idx(freq_data.pstate_id);
>   		reset_gpstates(policy);
> -		gpstates->highest_lpstate = freq_data.pstate_id;
> +		gpstates->highest_lpstate_idx = gpstate_idx;
>   	} else {
> -		gpstate_id = calc_global_pstate(gpstates->elapsed_time,
> -						gpstates->highest_lpstate,
> -						freq_data.pstate_id);
> +		gpstate_idx = calc_global_pstate(gpstates->elapsed_time,
> +						 gpstates->highest_lpstate_idx,
> +						 freq_data.pstate_id);
>   	}
>   
>   	/*
>   	 * If local pstate is equal to global pstate, rampdown is over
>   	 * So timer is not required to be queued.
>   	 */
> -	if (gpstate_id != freq_data.pstate_id)
> +	if (gpstate_idx != gpstates->last_lpstate_idx)
>   		queue_gpstate_timer(gpstates);
>   
> -	freq_data.gpstate_id = gpstate_id;
> -	gpstates->last_gpstate = freq_data.gpstate_id;
> -	gpstates->last_lpstate = freq_data.pstate_id;
> +	freq_data.gpstate_id = idx_to_pstate(gpstate_idx);
> +	gpstates->last_gpstate_idx = pstate_to_idx(freq_data.gpstate_id);
> +	gpstates->last_lpstate_idx = pstate_to_idx(freq_data.pstate_id);
>   
>   	spin_unlock(&gpstates->gpstate_lock);
>   
> @@ -596,7 +623,7 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy,
>   					unsigned int new_index)
>   {
>   	struct powernv_smp_call_data freq_data;
> -	unsigned int cur_msec, gpstate_id;
> +	unsigned int cur_msec, gpstate_idx;
>   	struct global_pstate_info *gpstates = policy->driver_data;
>   
>   	if (unlikely(rebooting) && new_index != get_nominal_index())
> @@ -608,15 +635,15 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy,
>   	cur_msec = jiffies_to_msecs(get_jiffies_64());
>   
>   	spin_lock(&gpstates->gpstate_lock);
> -	freq_data.pstate_id = powernv_freqs[new_index].driver_data;
> +	freq_data.pstate_id = idx_to_pstate(new_index);
>   
>   	if (!gpstates->last_sampled_time) {
> -		gpstate_id = freq_data.pstate_id;
> -		gpstates->highest_lpstate = freq_data.pstate_id;
> +		gpstate_idx = new_index;
> +		gpstates->highest_lpstate_idx = new_index;
>   		goto gpstates_done;
>   	}
>   
> -	if (gpstates->last_gpstate > freq_data.pstate_id) {
> +	if (gpstates->last_gpstate_idx < new_index) {
>   		gpstates->elapsed_time += cur_msec -
>   						 gpstates->last_sampled_time;
>   
> @@ -627,34 +654,34 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy,
>   		 */
>   		if (gpstates->elapsed_time > MAX_RAMP_DOWN_TIME) {
>   			reset_gpstates(policy);
> -			gpstates->highest_lpstate = freq_data.pstate_id;
> -			gpstate_id = freq_data.pstate_id;
> +			gpstates->highest_lpstate_idx = new_index;
> +			gpstate_idx = new_index;
>   		} else {
>   		/* Elaspsed_time is less than 5 seconds, continue to rampdown */
> -			gpstate_id = calc_global_pstate(gpstates->elapsed_time,
> -							gpstates->highest_lpstate,
> -							freq_data.pstate_id);
> +			gpstate_idx = calc_global_pstate(gpstates->elapsed_time,
> +							 gpstates->highest_lpstate_idx,
> +							 new_index);
>   		}
>   	} else {
>   		reset_gpstates(policy);
> -		gpstates->highest_lpstate = freq_data.pstate_id;
> -		gpstate_id = freq_data.pstate_id;
> +		gpstates->highest_lpstate_idx = new_index;
> +		gpstate_idx = new_index;
>   	}
>   
>   	/*
>   	 * If local pstate is equal to global pstate, rampdown is over
>   	 * So timer is not required to be queued.
>   	 */
> -	if (gpstate_id != freq_data.pstate_id)
> +	if (gpstate_idx != new_index)
>   		queue_gpstate_timer(gpstates);
>   	else
>   		del_timer_sync(&gpstates->timer);
>   
>   gpstates_done:
> -	freq_data.gpstate_id = gpstate_id;
> +	freq_data.gpstate_id = idx_to_pstate(gpstate_idx);
>   	gpstates->last_sampled_time = cur_msec;
> -	gpstates->last_gpstate = freq_data.gpstate_id;
> -	gpstates->last_lpstate = freq_data.pstate_id;
> +	gpstates->last_gpstate_idx = gpstate_idx;
> +	gpstates->last_lpstate_idx = new_index;
>   
>   	spin_unlock(&gpstates->gpstate_lock);
>   
> @@ -847,8 +874,8 @@ static void powernv_cpufreq_stop_cpu(struct cpufreq_policy *policy)
>   	struct powernv_smp_call_data freq_data;
>   	struct global_pstate_info *gpstates = policy->driver_data;
>   
> -	freq_data.pstate_id = powernv_pstate_info.min;
> -	freq_data.gpstate_id = powernv_pstate_info.min;
> +	freq_data.pstate_id = idx_to_pstate(powernv_pstate_info.min);
> +	freq_data.gpstate_id = idx_to_pstate(powernv_pstate_info.min);
>   	smp_call_function_single(policy->cpu, set_pstate, &freq_data, 1);
>   	del_timer_sync(&gpstates->timer);
>   }

Hi Viresh,
Any comments on this patch ?