Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "soc: qcom: rq_stats: clean up the rq_stats"

Browse source
This commit is contained in:
qctecmdr Service 2019-03-19 06:28:56 -07:00 committed by Gerrit - the friendly Code Review server
commit 873ba54b08
3 changed files with 0 additions and 311 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

276
drivers/soc/qcom/rq_stats.c
View file

@ -3,248 +3,21 @@
* Copyright (c) 2010-2015, 2017, 2019, The Linux Foundation. All rights reserved. * Copyright (c) 2010-2015, 2017, 2019, The Linux Foundation. All rights reserved.
*/ */
#include <linux/kernel.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h>
#include <linux/hrtimer.h>
#include <linux/cpu.h> #include <linux/cpu.h>
#include <linux/kobject.h> #include <linux/kobject.h>
#include <linux/sysfs.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/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 MAX_LONG_SIZE 24
#define DEFAULT_RQ_POLL_JIFFIES 1
#define DEFAULT_DEF_TIMER_JIFFIES 5 #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) static void def_work_fn(struct work_struct *work)
{ {
/* Notify polling threads on change of value */ /* Notify polling threads on change of value */
sysfs_notify(rq_info.kobj, NULL, "def_timer_ms"); 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, static ssize_t show_def_timer_ms(struct kobject *kobj,
struct kobj_attribute *attr, char *buf) struct kobj_attribute *attr, char *buf)
{ {
@ -276,22 +49,8 @@ static struct kobj_attribute def_timer_ms_attr =
__ATTR(def_timer_ms, 0600, show_def_timer_ms, __ATTR(def_timer_ms, 0600, show_def_timer_ms,
store_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[] = { static struct attribute *rq_attrs[] = {
&cpu_normalized_load_attr.attr,
&def_timer_ms_attr.attr, &def_timer_ms_attr.attr,
&run_queue_avg_attr.attr,
&run_queue_poll_ms_attr.attr,
&hotplug_disabled_attr.attr,
NULL, NULL,
}; };
@ -303,7 +62,6 @@ static int init_rq_attribs(void)
{ {
int err; int err;
rq_info.rq_avg = 0;
rq_info.attr_group = &rq_attr_group; rq_info.attr_group = &rq_attr_group;
/* Create /sys/devices/system/cpu/cpu0/rq-stats/... */ /* Create /sys/devices/system/cpu/cpu0/rq-stats/... */
@ -324,8 +82,6 @@ static int init_rq_attribs(void)
static int __init msm_rq_stats_init(void) static int __init msm_rq_stats_init(void)
{ {
int ret; int ret;
int i;
struct cpufreq_policy cpu_policy;
#ifndef CONFIG_SMP #ifndef CONFIG_SMP
/* Bail out if this is not an SMP Target */ /* Bail out if this is not an SMP Target */
@ -337,44 +93,12 @@ static int __init msm_rq_stats_init(void)
WARN_ON(!rq_wq); WARN_ON(!rq_wq);
INIT_WORK(&rq_info.def_timer_work, def_work_fn); INIT_WORK(&rq_info.def_timer_work, def_work_fn);
spin_lock_init(&rq_lock); 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.def_timer_jiffies = DEFAULT_DEF_TIMER_JIFFIES;
rq_info.rq_poll_last_jiffy = 0;
rq_info.def_timer_last_jiffy = 0; rq_info.def_timer_last_jiffy = 0;
rq_info.hotplug_disabled = 0;
ret = init_rq_attribs(); ret = init_rq_attribs();
rq_info.init = 1; 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; return ret;
} }
late_initcall(msm_rq_stats_init); 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);

6
include/linux/rq_stats.h
View file

@ -1,17 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0-only */ /* SPDX-License-Identifier: GPL-2.0-only */
/* /*
* Copyright (c) 2011,2013-2014,2019, The Linux Foundation. All rights reserved. * Copyright (c) 2011,2013-2014,2019, The Linux Foundation. All rights reserved.
*
*/ */
struct rq_data { struct rq_data {
unsigned int rq_avg;
unsigned long rq_poll_jiffies;
unsigned long def_timer_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 long def_timer_last_jiffy;
unsigned int hotplug_disabled;
int64_t def_start_time; int64_t def_start_time;
struct attribute_group *attr_group; struct attribute_group *attr_group;
struct kobject *kobj; struct kobject *kobj;

29
kernel/time/tick-sched.c
View file

@ -1264,31 +1264,6 @@ void tick_irq_enter(void)
* High resolution timer specific code * High resolution timer specific code
*/ */
#ifdef CONFIG_HIGH_RES_TIMERS #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) static void wakeup_user(void)
{ {
unsigned long jiffy_gap; unsigned long jiffy_gap;
@ -1321,10 +1296,6 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
tick_sched_handle(ts, regs); tick_sched_handle(ts, regs);
if (rq_info.init == 1 && if (rq_info.init == 1 &&
tick_do_timer_cpu == smp_processor_id()) { tick_do_timer_cpu == smp_processor_id()) {
/*
* update run queue statistics
*/
update_rq_stats();
/* /*
* wakeup user if needed * wakeup user if needed
*/ */