Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b27a7a3c authored by Runmin Wang's avatar Runmin Wang
Browse files

soc: qcom: rq_stats: clean up the rq_stats 



Remove unncessary function and data structure for rq_stats
since no driver relies on this information. Keep the defer_timer
kobj since irq balancer still needs this.

Change-Id: I20516fd7ed8496426ef75246c7b77c1937c696dc
Signed-off-by: default avatarRunmin Wang <runminw@codeaurora.org>
parent 4b205dc9

drivers/soc/qcom/rq_stats.c

+0 −275
Original line number Diff line number Diff line
@@ -11,248 +11,21 @@ 
 *

 */



#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/hrtimer.h>

#include <linux/cpu.h>

#include <linux/kobject.h>

#include <linux/sysfs.h>

#include <linux/notifier.h>

#include <linux/slab.h>

#include <linux/workqueue.h>

#include <linux/sched.h>

#include <linux/spinlock.h>

#include <linux/rq_stats.h>

#include <linux/cpufreq.h>

#include <linux/kernel_stat.h>

#include <linux/tick.h>

#include <asm/smp_plat.h>

#include <linux/suspend.h>



#define MAX_LONG_SIZE 24

#define DEFAULT_RQ_POLL_JIFFIES 1

#define DEFAULT_DEF_TIMER_JIFFIES 5



struct notifier_block freq_transition;



struct cpu_load_data {

	u64 prev_cpu_idle;

	u64 prev_cpu_wall;

	unsigned int avg_load_maxfreq;

	unsigned int samples;

	unsigned int window_size;

	unsigned int cur_freq;

	unsigned int policy_max;

	cpumask_var_t related_cpus;

	struct mutex cpu_load_mutex;

};



static DEFINE_PER_CPU(struct cpu_load_data, cpuload);





static int update_average_load(unsigned int freq, unsigned int cpu)

{



	struct cpu_load_data *pcpu = &per_cpu(cpuload, cpu);

	u64 cur_wall_time, cur_idle_time;

	unsigned int idle_time, wall_time;

	unsigned int cur_load, load_at_max_freq;



	cur_idle_time = get_cpu_idle_time(cpu, &cur_wall_time, 0);



	wall_time = (unsigned int) (cur_wall_time - pcpu->prev_cpu_wall);

	pcpu->prev_cpu_wall = cur_wall_time;



	idle_time = (unsigned int) (cur_idle_time - pcpu->prev_cpu_idle);

	pcpu->prev_cpu_idle = cur_idle_time;





	if (unlikely(wall_time <= 0 || wall_time < idle_time))

		return 0;



	cur_load = 100 * (wall_time - idle_time) / wall_time;



	/* Calculate the scaled load across CPU */

	load_at_max_freq = (cur_load * freq) / pcpu->policy_max;



	if (!pcpu->avg_load_maxfreq) {

		/* This is the first sample in this window*/

		pcpu->avg_load_maxfreq = load_at_max_freq;

		pcpu->window_size = wall_time;

	} else {

		/*

		 * The is already a sample available in this window.

		 * Compute weighted average with prev entry, so that we get

		 * the precise weighted load.

		 */

		pcpu->avg_load_maxfreq =

			((pcpu->avg_load_maxfreq * pcpu->window_size) +

			(load_at_max_freq * wall_time)) /

			(wall_time + pcpu->window_size);



		pcpu->window_size += wall_time;

	}



	return 0;

}



static unsigned int report_load_at_max_freq(void)

{

	int cpu;

	struct cpu_load_data *pcpu;

	unsigned int total_load = 0;



	for_each_online_cpu(cpu) {

		pcpu = &per_cpu(cpuload, cpu);

		mutex_lock(&pcpu->cpu_load_mutex);

		update_average_load(pcpu->cur_freq, cpu);

		total_load += pcpu->avg_load_maxfreq;

		pcpu->avg_load_maxfreq = 0;

		mutex_unlock(&pcpu->cpu_load_mutex);

	}

	return total_load;

}



static int cpufreq_transition_handler(struct notifier_block *nb,

			unsigned long val, void *data)

{

	struct cpufreq_freqs *freqs = data;

	struct cpu_load_data *this_cpu = &per_cpu(cpuload, freqs->cpu);

	int j;



	switch (val) {

	case CPUFREQ_POSTCHANGE:

		for_each_cpu(j, this_cpu->related_cpus) {

			struct cpu_load_data *pcpu = &per_cpu(cpuload, j);



			mutex_lock(&pcpu->cpu_load_mutex);

			update_average_load(freqs->old, j);

			pcpu->cur_freq = freqs->new;

			mutex_unlock(&pcpu->cpu_load_mutex);

		}

		break;

	}

	return 0;

}



static void update_related_cpus(void)

{

	unsigned int cpu;



	for_each_cpu(cpu, cpu_online_mask) {

		struct cpu_load_data *this_cpu = &per_cpu(cpuload, cpu);

		struct cpufreq_policy cpu_policy;



		cpufreq_get_policy(&cpu_policy, cpu);

		cpumask_copy(this_cpu->related_cpus, cpu_policy.cpus);

	}

}



static int cpu_online_handler(unsigned int cpu)

{

	struct cpu_load_data *this_cpu = &per_cpu(cpuload, cpu);



	if (!this_cpu->cur_freq)

		this_cpu->cur_freq = cpufreq_quick_get(cpu);

	update_related_cpus();

	this_cpu->avg_load_maxfreq = 0;

	return 0;

}



static int system_suspend_handler(struct notifier_block *nb,

				unsigned long val, void *data)

{

	switch (val) {

	case PM_POST_HIBERNATION:

	case PM_POST_SUSPEND:

	case PM_POST_RESTORE:

		rq_info.hotplug_disabled = 0;

		break;

	case PM_HIBERNATION_PREPARE:

	case PM_SUSPEND_PREPARE:

		rq_info.hotplug_disabled = 1;

		break;

	default:

		return NOTIFY_DONE;

	}

	return NOTIFY_OK;

}





static ssize_t hotplug_disable_show(struct kobject *kobj,

		struct kobj_attribute *attr, char *buf)

{

	unsigned int val = rq_info.hotplug_disabled;



	return snprintf(buf, MAX_LONG_SIZE, "%d\n", val);

}



static struct kobj_attribute hotplug_disabled_attr = __ATTR_RO(hotplug_disable);



static void def_work_fn(struct work_struct *work)

{

	/* Notify polling threads on change of value */

	sysfs_notify(rq_info.kobj, NULL, "def_timer_ms");

}



static ssize_t run_queue_avg_show(struct kobject *kobj,

		struct kobj_attribute *attr, char *buf)

{

	unsigned int val = 0;

	unsigned long flags = 0;



	spin_lock_irqsave(&rq_lock, flags);

	/* rq avg currently available only on one core */

	val = rq_info.rq_avg;

	rq_info.rq_avg = 0;

	spin_unlock_irqrestore(&rq_lock, flags);



	return snprintf(buf, PAGE_SIZE, "%d.%d\n", val/10, val%10);

}



static struct kobj_attribute run_queue_avg_attr = __ATTR_RO(run_queue_avg);



static ssize_t show_run_queue_poll_ms(struct kobject *kobj,

				      struct kobj_attribute *attr, char *buf)

{

	int ret = 0;

	unsigned long flags = 0;



	spin_lock_irqsave(&rq_lock, flags);

	ret = snprintf(buf, MAX_LONG_SIZE, "%u\n",

		       jiffies_to_msecs(rq_info.rq_poll_jiffies));

	spin_unlock_irqrestore(&rq_lock, flags);



	return ret;

}



static ssize_t store_run_queue_poll_ms(struct kobject *kobj,

				       struct kobj_attribute *attr,

				       const char *buf, size_t count)

{

	unsigned int val = 0;

	unsigned long flags = 0;

	static DEFINE_MUTEX(lock_poll_ms);



	mutex_lock(&lock_poll_ms);



	spin_lock_irqsave(&rq_lock, flags);

	if (kstrtouint(buf, 0, &val))

		count = -EINVAL;

	else

		rq_info.rq_poll_jiffies = msecs_to_jiffies(val);

	spin_unlock_irqrestore(&rq_lock, flags);



	mutex_unlock(&lock_poll_ms);



	return count;

}



static struct kobj_attribute run_queue_poll_ms_attr =

	__ATTR(run_queue_poll_ms, 0600, show_run_queue_poll_ms,

			store_run_queue_poll_ms);



static ssize_t show_def_timer_ms(struct kobject *kobj,

		struct kobj_attribute *attr, char *buf)

{
@@ -284,22 +57,8 @@ static struct kobj_attribute def_timer_ms_attr = 
	__ATTR(def_timer_ms, 0600, show_def_timer_ms,

			store_def_timer_ms);



static ssize_t show_cpu_normalized_load(struct kobject *kobj,

		struct kobj_attribute *attr, char *buf)

{

	return snprintf(buf, MAX_LONG_SIZE, "%u\n", report_load_at_max_freq());

}



static struct kobj_attribute cpu_normalized_load_attr =

	__ATTR(cpu_normalized_load, 0600, show_cpu_normalized_load,

			NULL);



static struct attribute *rq_attrs[] = {

	&cpu_normalized_load_attr.attr,

	&def_timer_ms_attr.attr,

	&run_queue_avg_attr.attr,

	&run_queue_poll_ms_attr.attr,

	&hotplug_disabled_attr.attr,

	NULL,

};
@@ -311,7 +70,6 @@ static int init_rq_attribs(void) 
{

	int err;



	rq_info.rq_avg = 0;

	rq_info.attr_group = &rq_attr_group;



	/* Create /sys/devices/system/cpu/cpu0/rq-stats/... */
@@ -333,7 +91,6 @@ static int __init msm_rq_stats_init(void) 
{

	int ret;

	int i;

	struct cpufreq_policy cpu_policy;



#ifndef CONFIG_SMP

	/* Bail out if this is not an SMP Target */
@@ -345,44 +102,12 @@ static int __init msm_rq_stats_init(void) 
	WARN_ON(!rq_wq);

	INIT_WORK(&rq_info.def_timer_work, def_work_fn);

	spin_lock_init(&rq_lock);

	rq_info.rq_poll_jiffies = DEFAULT_RQ_POLL_JIFFIES;

	rq_info.def_timer_jiffies = DEFAULT_DEF_TIMER_JIFFIES;

	rq_info.rq_poll_last_jiffy = 0;

	rq_info.def_timer_last_jiffy = 0;

	rq_info.hotplug_disabled = 0;

	ret = init_rq_attribs();



	rq_info.init = 1;



	for_each_possible_cpu(i) {

		struct cpu_load_data *pcpu = &per_cpu(cpuload, i);



		mutex_init(&pcpu->cpu_load_mutex);

		cpufreq_get_policy(&cpu_policy, i);

		pcpu->policy_max = cpu_policy.cpuinfo.max_freq;

		if (cpu_online(i))

			pcpu->cur_freq = cpufreq_quick_get(i);

		cpumask_copy(pcpu->related_cpus, cpu_policy.cpus);

	}

	freq_transition.notifier_call = cpufreq_transition_handler;

	cpufreq_register_notifier(&freq_transition,

					CPUFREQ_TRANSITION_NOTIFIER);

	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "rq_stats:online",

			cpu_online_handler, NULL);



	return ret;

}

late_initcall(msm_rq_stats_init);
 


static int __init msm_rq_stats_early_init(void)

{

#ifndef CONFIG_SMP

	/* Bail out if this is not an SMP Target */

	rq_info.init = 0;

	return -EPERM;

#endif



	pm_notifier(system_suspend_handler, 0);

	return 0;

}

core_initcall(msm_rq_stats_early_init);

include/linux/rq_stats.h

+1 −6
Original line number Diff line number Diff line 
/* Copyright (c) 2011,2013-2014, The Linux Foundation. All rights reserved.

/* Copyright (c) 2011,2013-2014,2017 The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -12,13 +12,8 @@ 
 */



struct rq_data {

	unsigned int rq_avg;

	unsigned long rq_poll_jiffies;

	unsigned long def_timer_jiffies;

	unsigned long rq_poll_last_jiffy;

	unsigned long rq_poll_total_jiffies;

	unsigned long def_timer_last_jiffy;

	unsigned int hotplug_disabled;

	int64_t def_start_time;

	struct attribute_group *attr_group;

	struct kobject *kobj;

kernel/time/tick-sched.c

+0 −29
Original line number Diff line number Diff line
@@ -1174,31 +1174,6 @@ void tick_irq_enter(void) 
 * High resolution timer specific code

 */

#ifdef CONFIG_HIGH_RES_TIMERS

static void update_rq_stats(void)

{

	unsigned long jiffy_gap = 0;

	unsigned int rq_avg = 0;

	unsigned long flags = 0;



	jiffy_gap = jiffies - rq_info.rq_poll_last_jiffy;

	if (jiffy_gap >= rq_info.rq_poll_jiffies) {

		spin_lock_irqsave(&rq_lock, flags);

		if (!rq_info.rq_avg)

			rq_info.rq_poll_total_jiffies = 0;

		rq_avg = nr_running() * 10;

		if (rq_info.rq_poll_total_jiffies) {

			rq_avg = (rq_avg * jiffy_gap) +

				(rq_info.rq_avg *

				 rq_info.rq_poll_total_jiffies);

			do_div(rq_avg,

				rq_info.rq_poll_total_jiffies + jiffy_gap);

		}

		rq_info.rq_avg = rq_avg;

		rq_info.rq_poll_total_jiffies += jiffy_gap;

		rq_info.rq_poll_last_jiffy = jiffies;

		spin_unlock_irqrestore(&rq_lock, flags);

	}

}

static void wakeup_user(void)

{

	unsigned long jiffy_gap;
@@ -1231,10 +1206,6 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer) 
		tick_sched_handle(ts, regs);

		if (rq_info.init == 1 &&

				tick_do_timer_cpu == smp_processor_id()) {

			/*

			 * update run queue statistics

			 */

			update_rq_stats();

			/*

			 * wakeup user if needed

			 */