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

Commit e8b54c76 authored by Satya Durga Srinivasu Prabhala's avatar Satya Durga Srinivasu Prabhala Committed by Gerrit - the friendly Code Review server
Browse files

sched/fair: Add snapshot of load-balancing changes 



This snapshot is taken from msm-4.19 as of commit 89986132507b822
("sched: fair: Improve the scheduler").

Change-Id: I75555a04020478e8d589b6a0fba209501c360dad
Signed-off-by: default avatarSatya Durga Srinivasu Prabhala <satyap@codeaurora.org>
parent fb133230

include/trace/events/sched.h

+228 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#include <linux/sched/numa_balancing.h>

#include <linux/tracepoint.h>

#include <linux/binfmts.h>

#include <linux/sched/idle.h>



/*

 * Tracepoint for calling kthread_stop, performed to end a kthread:
@@ -259,6 +260,233 @@ TRACE_EVENT(sched_migrate_task, 
		  __entry->orig_cpu, __entry->dest_cpu)

);



/*

 * Tracepoint for load balancing:

 */

#ifdef CONFIG_SMP

#if NR_CPUS > BITS_PER_LONG

#define trace_sched_load_balance_sg_stats(...)

#define trace_sched_load_balance_stats(...)

#define trace_sched_load_balance(...)

#define trace_sched_load_balance_nohz_kick(...)

#else

TRACE_EVENT(sched_load_balance,



	TP_PROTO(int cpu, enum cpu_idle_type idle, int balance,

		unsigned long group_mask, int busiest_nr_running,

		unsigned long imbalance, unsigned int env_flags, int ld_moved,

		unsigned int balance_interval, int active_balance),



	TP_ARGS(cpu, idle, balance, group_mask, busiest_nr_running,

		imbalance, env_flags, ld_moved, balance_interval,

		active_balance),



	TP_STRUCT__entry(

		__field(int,                    cpu)

		__field(enum cpu_idle_type,     idle)

		__field(int,                    balance)

		__field(unsigned long,          group_mask)

		__field(int,                    busiest_nr_running)

		__field(unsigned long,          imbalance)

		__field(unsigned int,           env_flags)

		__field(int,                    ld_moved)

		__field(unsigned int,           balance_interval)

		__field(int,                    active_balance)

	),



	TP_fast_assign(

		__entry->cpu                    = cpu;

		__entry->idle                   = idle;

		__entry->balance                = balance;

		__entry->group_mask             = group_mask;

		__entry->busiest_nr_running     = busiest_nr_running;

		__entry->imbalance              = imbalance;

		__entry->env_flags              = env_flags;

		__entry->ld_moved               = ld_moved;

		__entry->balance_interval       = balance_interval;

		__entry->active_balance		= active_balance;

	),



	TP_printk("cpu=%d state=%s balance=%d group=%#lx busy_nr=%d imbalance=%ld flags=%#x ld_moved=%d bal_int=%d active_balance=%d",

		__entry->cpu,

		__entry->idle == CPU_IDLE ? "idle" :

		(__entry->idle == CPU_NEWLY_IDLE ? "newly_idle" : "busy"),

		__entry->balance,

		__entry->group_mask, __entry->busiest_nr_running,

		__entry->imbalance, __entry->env_flags, __entry->ld_moved,

		__entry->balance_interval, __entry->active_balance)

);



TRACE_EVENT(sched_load_balance_nohz_kick,



	TP_PROTO(int cpu, int kick_cpu),



	TP_ARGS(cpu, kick_cpu),



	TP_STRUCT__entry(

		__field(int,		cpu)

		__field(unsigned int,	cpu_nr)

		__field(unsigned long,	misfit_task_load)

		__field(int,		cpu_overutil)

		__field(int,		kick_cpu)

		__field(unsigned long,	nohz_flags)

	),



	TP_fast_assign(

		__entry->cpu	          = cpu;

		__entry->cpu_nr		  = cpu_rq(cpu)->nr_running;

		__entry->misfit_task_load = cpu_rq(cpu)->misfit_task_load;

		__entry->cpu_overutil	  = cpu_overutilized(cpu);

		__entry->kick_cpu	  = kick_cpu;

		__entry->nohz_flags	  = atomic_read(nohz_flags(kick_cpu));

	),



	TP_printk("cpu=%d nr_run=%u misfit_task_load=%lu overutilized=%d kick_cpu=%d nohz_flags=0x%lx",

			__entry->cpu, __entry->cpu_nr,

			__entry->misfit_task_load, __entry->cpu_overutil,

			__entry->kick_cpu, __entry->nohz_flags)



);



TRACE_EVENT(sched_load_balance_sg_stats,



	TP_PROTO(unsigned long sg_cpus, int group_type, unsigned int idle_cpus,

		unsigned int sum_nr_running, unsigned long group_load,

		unsigned long group_capacity, unsigned long group_util,

		int group_no_capacity, unsigned long load_per_task,

		unsigned long misfit_load, unsigned long busiest),



	TP_ARGS(sg_cpus, group_type, idle_cpus, sum_nr_running, group_load,

		group_capacity, group_util, group_no_capacity, load_per_task,

		misfit_load, busiest),



	TP_STRUCT__entry(

		__field(unsigned long,		group_mask)

		__field(int,			group_type)

		__field(unsigned int,		group_idle_cpus)

		__field(unsigned int,		sum_nr_running)

		__field(unsigned long,		group_load)

		__field(unsigned long,		group_capacity)

		__field(unsigned long,		group_util)

		__field(int,			group_no_capacity)

		__field(unsigned long,		load_per_task)

		__field(unsigned long,		misfit_task_load)

		__field(unsigned long,		busiest)

	),



	TP_fast_assign(

		__entry->group_mask			= sg_cpus;

		__entry->group_type			= group_type;

		__entry->group_idle_cpus		= idle_cpus;

		__entry->sum_nr_running			= sum_nr_running;

		__entry->group_load			= group_load;

		__entry->group_capacity			= group_capacity;

		__entry->group_util			= group_util;

		__entry->group_no_capacity		= group_no_capacity;

		__entry->load_per_task			= load_per_task;

		__entry->misfit_task_load		= misfit_load;

		__entry->busiest			= busiest;

	),



	TP_printk("sched_group=%#lx type=%d idle_cpus=%u sum_nr_run=%u group_load=%lu capacity=%lu util=%lu no_capacity=%d lpt=%lu misfit_tload=%lu busiest_group=%#lx",

		__entry->group_mask, __entry->group_type,

		__entry->group_idle_cpus, __entry->sum_nr_running,

		__entry->group_load, __entry->group_capacity,

		__entry->group_util, __entry->group_no_capacity,

		__entry->load_per_task, __entry->misfit_task_load,

		__entry->busiest)

);



TRACE_EVENT(sched_load_balance_stats,



	TP_PROTO(unsigned long busiest, int bgroup_type,

		unsigned long bavg_load, unsigned long bload_per_task,

		unsigned long local, int lgroup_type, unsigned long lavg_load,

		unsigned long lload_per_task, unsigned long sds_avg_load,

		unsigned long imbalance),



	TP_ARGS(busiest, bgroup_type, bavg_load, bload_per_task, local,

		lgroup_type, lavg_load, lload_per_task, sds_avg_load,

		imbalance),



	TP_STRUCT__entry(

		__field(unsigned long,		busiest)

		__field(int,			bgp_type)

		__field(unsigned long,		bavg_load)

		__field(unsigned long,		blpt)

		__field(unsigned long,		local)

		__field(int,			lgp_type)

		__field(unsigned long,		lavg_load)

		__field(unsigned long,		llpt)

		__field(unsigned long,		sds_avg)

		__field(unsigned long,		imbalance)

	),



	TP_fast_assign(

		__entry->busiest			= busiest;

		__entry->bgp_type			= bgroup_type;

		__entry->bavg_load			= bavg_load;

		__entry->blpt				= bload_per_task;

		__entry->bgp_type			= bgroup_type;

		__entry->local				= local;

		__entry->lgp_type			= lgroup_type;

		__entry->lavg_load			= lavg_load;

		__entry->llpt				= lload_per_task;

		__entry->sds_avg			= sds_avg_load;

		__entry->imbalance			= imbalance;

	),



	TP_printk("busiest_group=%#lx busiest_type=%d busiest_avg_load=%ld busiest_lpt=%ld local_group=%#lx local_type=%d local_avg_load=%ld local_lpt=%ld domain_avg_load=%ld imbalance=%ld",

		__entry->busiest, __entry->bgp_type, __entry->bavg_load,

		__entry->blpt, __entry->local, __entry->lgp_type,

		__entry->lavg_load, __entry->llpt, __entry->sds_avg,

		__entry->imbalance)

);

#endif /* NR_CPUS > BITS_PER_LONG */

#endif /* CONFIG_SMP */



#ifdef CONFIG_SCHED_WALT

TRACE_EVENT(sched_load_balance_skip_tasks,



	TP_PROTO(int scpu, int dcpu, int grp_type, int pid,

		unsigned long h_load, unsigned long task_util,

		unsigned long affinity),



	TP_ARGS(scpu, dcpu, grp_type, pid, h_load, task_util, affinity),



	TP_STRUCT__entry(

		__field(int,            scpu)

		__field(unsigned long,  src_util_cum)

		__field(int,            grp_type)

		__field(int,            dcpu)

		__field(unsigned long,  dst_util_cum)

		__field(int,            pid)

		__field(unsigned long,  affinity)

		__field(unsigned long,  task_util)

		__field(unsigned long,  h_load)

	),



	TP_fast_assign(

		__entry->scpu           = scpu;

		__entry->src_util_cum   =

					cpu_rq(scpu)->cum_window_demand_scaled;

		__entry->grp_type       = grp_type;

		__entry->dcpu           = dcpu;

		__entry->dst_util_cum   =

					cpu_rq(dcpu)->cum_window_demand_scaled;

		__entry->pid            = pid;

		__entry->affinity       = affinity;

		__entry->task_util      = task_util;

		__entry->h_load         = h_load;

	),



	TP_printk("source_cpu=%d util_cum=%lu group_type=%d dest_cpu=%d util_cum=%lu pid=%d affinity=%#lx task_util=%lu task_h_load=%lu",

		__entry->scpu, __entry->src_util_cum, __entry->grp_type,

		__entry->dcpu, __entry->dst_util_cum, __entry->pid,

		__entry->affinity, __entry->task_util, __entry->h_load)

);

#endif



DECLARE_EVENT_CLASS(sched_process_template,



	TP_PROTO(struct task_struct *p),

kernel/sched/fair.c

+365 −38

File changed.

Preview size limit exceeded, changes collapsed.

kernel/sched/sched.h

+37 −0
Original line number Diff line number Diff line
@@ -1986,6 +1986,9 @@ extern void trigger_load_balance(struct rq *rq); 


extern void set_cpus_allowed_common(struct task_struct *p, const struct cpumask *new_mask);



bool __cpu_overutilized(int cpu, int delta);

bool cpu_overutilized(int cpu);



#endif



#ifdef CONFIG_CPU_IDLE
@@ -2904,6 +2907,35 @@ static inline int asym_cap_siblings(int cpu1, int cpu2) 
		cpumask_test_cpu(cpu2, &asym_cap_sibling_cpus));

}



static inline bool asym_cap_sibling_group_has_capacity(int dst_cpu, int margin)

{

	int sib1, sib2;

	int nr_running;

	unsigned long total_util, total_capacity;



	if (cpumask_empty(&asym_cap_sibling_cpus) ||

			cpumask_test_cpu(dst_cpu, &asym_cap_sibling_cpus))

		return false;



	sib1 = cpumask_first(&asym_cap_sibling_cpus);

	sib2 = cpumask_last(&asym_cap_sibling_cpus);



	if (!cpu_active(sib1) || cpu_isolated(sib1) ||

		!cpu_active(sib2) || cpu_isolated(sib2))

		return false;



	nr_running = cpu_rq(sib1)->cfs.h_nr_running +

			cpu_rq(sib2)->cfs.h_nr_running;



	if (nr_running <= 2)

		return true;



	total_capacity = capacity_of(sib1) + capacity_of(sib2);

	total_util = cpu_util(sib1) + cpu_util(sib2);



	return ((total_capacity * 100) > (total_util * margin));

}



static inline int cpu_max_possible_capacity(int cpu)

{

	return cpu_rq(cpu)->cluster->max_possible_capacity;
@@ -3194,6 +3226,11 @@ static inline struct sched_cluster *rq_cluster(struct rq *rq) 


static inline int asym_cap_siblings(int cpu1, int cpu2) { return 0; }



static inline bool asym_cap_sibling_group_has_capacity(int dst_cpu, int margin)

{

	return false;

}



static inline void set_preferred_cluster(struct related_thread_group *grp) { }



static inline bool task_in_related_thread_group(struct task_struct *p)