sched/fair: Remove effective_load() (815abf5a) · Commits · e / devices / android_kernel_xiaomi_sm6125

kernel/sched/fair.c

+1 −123

Original line number	Original line	Diff line number	Diff line
	@@ -1382,7 +1382,6 @@ static unsigned long weighted_cpuload(const int cpu);
	static unsigned long source_load(int cpu, int type);		static unsigned long source_load(int cpu, int type);
	static unsigned long target_load(int cpu, int type);		static unsigned long target_load(int cpu, int type);
	static unsigned long capacity_of(int cpu);		static unsigned long capacity_of(int cpu);
	static long effective_load(struct task_group *tg, int cpu, long wl, long wg);

	/* Cached statistics for all CPUs within a node */		/* Cached statistics for all CPUs within a node */
	struct numa_stats {		struct numa_stats {
	@@ -3045,8 +3044,7 @@ __update_load_avg_cfs_rq(u64 now, int cpu, struct cfs_rq *cfs_rq)
	* differential update where we store the last value we propagated. This in		* differential update where we store the last value we propagated. This in
	* turn allows skipping updates if the differential is 'small'.		* turn allows skipping updates if the differential is 'small'.
	*		*
	* Updating tg's load_avg is necessary before update_cfs_share() (which is		* Updating tg's load_avg is necessary before update_cfs_share().
	* done) and effective_load() (which is not done because it is too costly).
	*/		*/
	static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)		static inline void update_tg_load_avg(struct cfs_rq *cfs_rq, int force)
	{		{
	@@ -5298,126 +5296,6 @@ static unsigned long cpu_avg_load_per_task(int cpu)
	return 0;		return 0;
	}		}

	#ifdef CONFIG_FAIR_GROUP_SCHED
	/*
	* effective_load() calculates the load change as seen from the root_task_group
	*
	* Adding load to a group doesn't make a group heavier, but can cause movement
	* of group shares between cpus. Assuming the shares were perfectly aligned one
	* can calculate the shift in shares.
	*
	* Calculate the effective load difference if @wl is added (subtracted) to @tg
	* on this @cpu and results in a total addition (subtraction) of @wg to the
	* total group weight.
	*
	* Given a runqueue weight distribution (rw_i) we can compute a shares
	* distribution (s_i) using:
	*
	* s_i = rw_i / \Sum rw_j (1)
	*
	* Suppose we have 4 CPUs and our @tg is a direct child of the root group and
	* has 7 equal weight tasks, distributed as below (rw_i), with the resulting
	* shares distribution (s_i):
	*
	* rw_i = { 2, 4, 1, 0 }
	* s_i = { 2/7, 4/7, 1/7, 0 }
	*
	* As per wake_affine() we're interested in the load of two CPUs (the CPU the
	* task used to run on and the CPU the waker is running on), we need to
	* compute the effect of waking a task on either CPU and, in case of a sync
	* wakeup, compute the effect of the current task going to sleep.
	*
	* So for a change of @wl to the local @cpu with an overall group weight change
	* of @wl we can compute the new shares distribution (s'_i) using:
	*
	* s'_i = (rw_i + @wl) / (@wg + \Sum rw_j) (2)
	*
	* Suppose we're interested in CPUs 0 and 1, and want to compute the load
	* differences in waking a task to CPU 0. The additional task changes the
	* weight and shares distributions like:
	*
	* rw'_i = { 3, 4, 1, 0 }
	* s'_i = { 3/8, 4/8, 1/8, 0 }
	*
	* We can then compute the difference in effective weight by using:
	*
	* dw_i = S * (s'_i - s_i) (3)
	*
	* Where 'S' is the group weight as seen by its parent.
	*
	* Therefore the effective change in loads on CPU 0 would be 5/56 (3/8 - 2/7)
	* times the weight of the group. The effect on CPU 1 would be -4/56 (4/8 -
	* 4/7) times the weight of the group.
	*/
	static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
	{
	struct sched_entity *se = tg->se[cpu];

	if (!tg->parent) /* the trivial, non-cgroup case */
	return wl;

	for_each_sched_entity(se) {
	struct cfs_rq *cfs_rq = se->my_q;
	long W, w = cfs_rq_load_avg(cfs_rq);

	tg = cfs_rq->tg;

	/*
	* W = @wg + \Sum rw_j
	*/
	W = wg + atomic_long_read(&tg->load_avg);

	/* Ensure \Sum rw_j >= rw_i */
	W -= cfs_rq->tg_load_avg_contrib;
	W += w;

	/*
	* w = rw_i + @wl
	*/
	w += wl;

	/*
	* wl = S * s'_i; see (2)
	*/
	if (W > 0 && w < W)
	wl = (w * (long)scale_load_down(tg->shares)) / W;
	else
	wl = scale_load_down(tg->shares);

	/*
	* Per the above, wl is the new se->load.weight value; since
	* those are clipped to [MIN_SHARES, ...) do so now. See
	* calc_cfs_shares().
	*/
	if (wl < MIN_SHARES)
	wl = MIN_SHARES;

	/*
	* wl = dw_i = S * (s'_i - s_i); see (3)
	*/
	wl -= se->avg.load_avg;

	/*
	* Recursively apply this logic to all parent groups to compute
	* the final effective load change on the root group. Since
	* only the @tg group gets extra weight, all parent groups can
	* only redistribute existing shares. @wl is the shift in shares
	* resulting from this level per the above.
	*/
	wg = 0;
	}

	return wl;
	}
	#else

	static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
	{
	return wl;
	}

	#endif

	static void record_wakee(struct task_struct *p)		static void record_wakee(struct task_struct *p)
	{		{
	/*		/*