Merge branch 'for-linus' of... (87baa2bb) · Commits · e / devices / android_kernel_samsung_universal8895

include/linux/sched.h

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -1542,10 +1542,6 @@ extern unsigned int sysctl_sched_child_runs_first;
	extern unsigned int sysctl_sched_features;		extern unsigned int sysctl_sched_features;
	extern unsigned int sysctl_sched_migration_cost;		extern unsigned int sysctl_sched_migration_cost;
	extern unsigned int sysctl_sched_nr_migrate;		extern unsigned int sysctl_sched_nr_migrate;
	#if defined(CONFIG_FAIR_GROUP_SCHED) && defined(CONFIG_SMP)
	extern unsigned int sysctl_sched_min_bal_int_shares;
	extern unsigned int sysctl_sched_max_bal_int_shares;
	#endif

	int sched_nr_latency_handler(struct ctl_table *table, int write,		int sched_nr_latency_handler(struct ctl_table *table, int write,
	struct file file, void __user buffer, size_t *length,		struct file file, void __user buffer, size_t *length,

kernel/sched.c

+35 −248

Original line number	Original line	Diff line number	Diff line
	@@ -174,41 +174,6 @@ struct task_group {
	struct sched_entity **se;		struct sched_entity **se;
	/* runqueue "owned" by this group on each cpu */		/* runqueue "owned" by this group on each cpu */
	struct cfs_rq **cfs_rq;		struct cfs_rq **cfs_rq;

	/*
	* shares assigned to a task group governs how much of cpu bandwidth
	* is allocated to the group. The more shares a group has, the more is
	* the cpu bandwidth allocated to it.
	*
	* For ex, lets say that there are three task groups, A, B and C which
	* have been assigned shares 1000, 2000 and 3000 respectively. Then,
	* cpu bandwidth allocated by the scheduler to task groups A, B and C
	* should be:
	*
	* Bw(A) = 1000/(1000+2000+3000) * 100 = 16.66%
	* Bw(B) = 2000/(1000+2000+3000) * 100 = 33.33%
	* Bw(C) = 3000/(1000+2000+3000) * 100 = 50%
	*
	* The weight assigned to a task group's schedulable entities on every
	* cpu (task_group.se[a_cpu]->load.weight) is derived from the task
	* group's shares. For ex: lets say that task group A has been
	* assigned shares of 1000 and there are two CPUs in a system. Then,
	*
	* tg_A->se[0]->load.weight = tg_A->se[1]->load.weight = 1000;
	*
	* Note: It's not necessary that each of a task's group schedulable
	* entity have the same weight on all CPUs. If the group
	* has 2 of its tasks on CPU0 and 1 task on CPU1, then a
	* better distribution of weight could be:
	*
	* tg_A->se[0]->load.weight = 2/3 * 2000 = 1333
	* tg_A->se[1]->load.weight = 1/2 * 2000 = 667
	*
	* rebalance_shares() is responsible for distributing the shares of a
	* task groups like this among the group's schedulable entities across
	* cpus.
	*
	*/
	unsigned long shares;		unsigned long shares;
	#endif		#endif

	@@ -250,22 +215,12 @@ static DEFINE_SPINLOCK(task_group_lock);
	static DEFINE_MUTEX(doms_cur_mutex);		static DEFINE_MUTEX(doms_cur_mutex);

	#ifdef CONFIG_FAIR_GROUP_SCHED		#ifdef CONFIG_FAIR_GROUP_SCHED
	#ifdef CONFIG_SMP
	/* kernel thread that runs rebalance_shares() periodically */
	static struct task_struct *lb_monitor_task;
	static int load_balance_monitor(void *unused);
	#endif

	static void set_se_shares(struct sched_entity *se, unsigned long shares);

	#ifdef CONFIG_USER_SCHED		#ifdef CONFIG_USER_SCHED
	# define INIT_TASK_GROUP_LOAD (2*NICE_0_LOAD)		# define INIT_TASK_GROUP_LOAD (2*NICE_0_LOAD)
	#else		#else
	# define INIT_TASK_GROUP_LOAD NICE_0_LOAD		# define INIT_TASK_GROUP_LOAD NICE_0_LOAD
	#endif		#endif

	#define MIN_GROUP_SHARES 2

	static int init_task_group_load = INIT_TASK_GROUP_LOAD;		static int init_task_group_load = INIT_TASK_GROUP_LOAD;
	#endif		#endif

	@@ -1245,16 +1200,6 @@ static void cpuacct_charge(struct task_struct *tsk, u64 cputime);
	static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}		static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
	#endif		#endif

	static inline void inc_cpu_load(struct rq *rq, unsigned long load)
	{
	update_load_add(&rq->load, load);
	}

	static inline void dec_cpu_load(struct rq *rq, unsigned long load)
	{
	update_load_sub(&rq->load, load);
	}

	#ifdef CONFIG_SMP		#ifdef CONFIG_SMP
	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);
	@@ -1272,14 +1217,26 @@ static int task_hot(struct task_struct p, u64 now, struct sched_domain sd);

	#define sched_class_highest (&rt_sched_class)		#define sched_class_highest (&rt_sched_class)

	static void inc_nr_running(struct rq *rq)		static inline void inc_load(struct rq rq, const struct task_struct p)
			{
			update_load_add(&rq->load, p->se.load.weight);
			}

			static inline void dec_load(struct rq rq, const struct task_struct p)
			{
			update_load_sub(&rq->load, p->se.load.weight);
			}

			static void inc_nr_running(struct task_struct p, struct rq rq)
	{		{
	rq->nr_running++;		rq->nr_running++;
			inc_load(rq, p);
	}		}

	static void dec_nr_running(struct rq *rq)		static void dec_nr_running(struct task_struct p, struct rq rq)
	{		{
	rq->nr_running--;		rq->nr_running--;
			dec_load(rq, p);
	}		}

	static void set_load_weight(struct task_struct *p)		static void set_load_weight(struct task_struct *p)
	@@ -1371,7 +1328,7 @@ static void activate_task(struct rq rq, struct task_struct p, int wakeup)
	rq->nr_uninterruptible--;		rq->nr_uninterruptible--;

	enqueue_task(rq, p, wakeup);		enqueue_task(rq, p, wakeup);
	inc_nr_running(rq);		inc_nr_running(p, rq);
	}		}

	/*		/*
	@@ -1383,7 +1340,7 @@ static void deactivate_task(struct rq rq, struct task_struct p, int sleep)
	rq->nr_uninterruptible++;		rq->nr_uninterruptible++;

	dequeue_task(rq, p, sleep);		dequeue_task(rq, p, sleep);
	dec_nr_running(rq);		dec_nr_running(p, rq);
	}		}

	/**		/**
	@@ -2023,7 +1980,7 @@ void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
	* management (if any):		* management (if any):
	*/		*/
	p->sched_class->task_new(rq, p);		p->sched_class->task_new(rq, p);
	inc_nr_running(rq);		inc_nr_running(p, rq);
	}		}
	check_preempt_curr(rq, p);		check_preempt_curr(rq, p);
	#ifdef CONFIG_SMP		#ifdef CONFIG_SMP
	@@ -4362,8 +4319,10 @@ void set_user_nice(struct task_struct *p, long nice)
	goto out_unlock;		goto out_unlock;
	}		}
	on_rq = p->se.on_rq;		on_rq = p->se.on_rq;
	if (on_rq)		if (on_rq) {
	dequeue_task(rq, p, 0);		dequeue_task(rq, p, 0);
			dec_load(rq, p);
			}

	p->static_prio = NICE_TO_PRIO(nice);		p->static_prio = NICE_TO_PRIO(nice);
	set_load_weight(p);		set_load_weight(p);
	@@ -4373,6 +4332,7 @@ void set_user_nice(struct task_struct *p, long nice)

	if (on_rq) {		if (on_rq) {
	enqueue_task(rq, p, 0);		enqueue_task(rq, p, 0);
			inc_load(rq, p);
	/*		/*
	* If the task increased its priority or is running and		* If the task increased its priority or is running and
	* lowered its priority, then reschedule its CPU:		* lowered its priority, then reschedule its CPU:
	@@ -7087,21 +7047,6 @@ void __init sched_init_smp(void)
	if (set_cpus_allowed(current, non_isolated_cpus) < 0)		if (set_cpus_allowed(current, non_isolated_cpus) < 0)
	BUG();		BUG();
	sched_init_granularity();		sched_init_granularity();

	#ifdef CONFIG_FAIR_GROUP_SCHED
	if (nr_cpu_ids == 1)
	return;

	lb_monitor_task = kthread_create(load_balance_monitor, NULL,
	"group_balance");
	if (!IS_ERR(lb_monitor_task)) {
	lb_monitor_task->flags \|= PF_NOFREEZE;
	wake_up_process(lb_monitor_task);
	} else {
	printk(KERN_ERR "Could not create load balance monitor thread"
	"(error = %ld) \n", PTR_ERR(lb_monitor_task));
	}
	#endif
	}		}
	#else		#else
	void __init sched_init_smp(void)		void __init sched_init_smp(void)
	@@ -7424,157 +7369,6 @@ void set_curr_task(int cpu, struct task_struct *p)

	#ifdef CONFIG_GROUP_SCHED		#ifdef CONFIG_GROUP_SCHED

	#if defined CONFIG_FAIR_GROUP_SCHED && defined CONFIG_SMP
	/*
	* distribute shares of all task groups among their schedulable entities,
	* to reflect load distribution across cpus.
	*/
	static int rebalance_shares(struct sched_domain *sd, int this_cpu)
	{
	struct cfs_rq *cfs_rq;
	struct rq *rq = cpu_rq(this_cpu);
	cpumask_t sdspan = sd->span;
	int balanced = 1;

	/* Walk thr' all the task groups that we have */
	for_each_leaf_cfs_rq(rq, cfs_rq) {
	int i;
	unsigned long total_load = 0, total_shares;
	struct task_group *tg = cfs_rq->tg;

	/* Gather total task load of this group across cpus */
	for_each_cpu_mask(i, sdspan)
	total_load += tg->cfs_rq[i]->load.weight;

	/* Nothing to do if this group has no load */
	if (!total_load)
	continue;

	/*
	* tg->shares represents the number of cpu shares the task group
	* is eligible to hold on a single cpu. On N cpus, it is
	* eligible to hold (N * tg->shares) number of cpu shares.
	*/
	total_shares = tg->shares * cpus_weight(sdspan);

	/*
	* redistribute total_shares across cpus as per the task load
	* distribution.
	*/
	for_each_cpu_mask(i, sdspan) {
	unsigned long local_load, local_shares;

	local_load = tg->cfs_rq[i]->load.weight;
	local_shares = (local_load * total_shares) / total_load;
	if (!local_shares)
	local_shares = MIN_GROUP_SHARES;
	if (local_shares == tg->se[i]->load.weight)
	continue;

	spin_lock_irq(&cpu_rq(i)->lock);
	set_se_shares(tg->se[i], local_shares);
	spin_unlock_irq(&cpu_rq(i)->lock);
	balanced = 0;
	}
	}

	return balanced;
	}

	/*
	* How frequently should we rebalance_shares() across cpus?
	*
	* The more frequently we rebalance shares, the more accurate is the fairness
	* of cpu bandwidth distribution between task groups. However higher frequency
	* also implies increased scheduling overhead.
	*
	* sysctl_sched_min_bal_int_shares represents the minimum interval between
	* consecutive calls to rebalance_shares() in the same sched domain.
	*
	* sysctl_sched_max_bal_int_shares represents the maximum interval between
	* consecutive calls to rebalance_shares() in the same sched domain.
	*
	* These settings allows for the appropriate trade-off between accuracy of
	* fairness and the associated overhead.
	*
	*/

	/* default: 8ms, units: milliseconds */
	const_debug unsigned int sysctl_sched_min_bal_int_shares = 8;

	/* default: 128ms, units: milliseconds */
	const_debug unsigned int sysctl_sched_max_bal_int_shares = 128;

	/* kernel thread that runs rebalance_shares() periodically */
	static int load_balance_monitor(void *unused)
	{
	unsigned int timeout = sysctl_sched_min_bal_int_shares;
	struct sched_param schedparm;
	int ret;

	/*
	* We don't want this thread's execution to be limited by the shares
	* assigned to default group (init_task_group). Hence make it run
	* as a SCHED_RR RT task at the lowest priority.
	*/
	schedparm.sched_priority = 1;
	ret = sched_setscheduler(current, SCHED_RR, &schedparm);
	if (ret)
	printk(KERN_ERR "Couldn't set SCHED_RR policy for load balance"
	" monitor thread (error = %d) \n", ret);

	while (!kthread_should_stop()) {
	int i, cpu, balanced = 1;

	/* Prevent cpus going down or coming up */
	get_online_cpus();
	/* lockout changes to doms_cur[] array */
	lock_doms_cur();
	/*
	* Enter a rcu read-side critical section to safely walk rq->sd
	* chain on various cpus and to walk task group list
	* (rq->leaf_cfs_rq_list) in rebalance_shares().
	*/
	rcu_read_lock();

	for (i = 0; i < ndoms_cur; i++) {
	cpumask_t cpumap = doms_cur[i];
	struct sched_domain sd = NULL, sd_prev = NULL;

	cpu = first_cpu(cpumap);

	/* Find the highest domain at which to balance shares */
	for_each_domain(cpu, sd) {
	if (!(sd->flags & SD_LOAD_BALANCE))
	continue;
	sd_prev = sd;
	}

	sd = sd_prev;
	/* sd == NULL? No load balance reqd in this domain */
	if (!sd)
	continue;

	balanced &= rebalance_shares(sd, cpu);
	}

	rcu_read_unlock();

	unlock_doms_cur();
	put_online_cpus();

	if (!balanced)
	timeout = sysctl_sched_min_bal_int_shares;
	else if (timeout < sysctl_sched_max_bal_int_shares)
	timeout *= 2;

	msleep_interruptible(timeout);
	}

	return 0;
	}
	#endif /* CONFIG_SMP */

	#ifdef CONFIG_FAIR_GROUP_SCHED		#ifdef CONFIG_FAIR_GROUP_SCHED
	static void free_fair_sched_group(struct task_group *tg)		static void free_fair_sched_group(struct task_group *tg)
	{		{
	@@ -7841,29 +7635,25 @@ void sched_move_task(struct task_struct *tsk)
	}		}

	#ifdef CONFIG_FAIR_GROUP_SCHED		#ifdef CONFIG_FAIR_GROUP_SCHED
	/* rq->lock to be locked by caller */
	static void set_se_shares(struct sched_entity *se, unsigned long shares)		static void set_se_shares(struct sched_entity *se, unsigned long shares)
	{		{
	struct cfs_rq *cfs_rq = se->cfs_rq;		struct cfs_rq *cfs_rq = se->cfs_rq;
	struct rq *rq = cfs_rq->rq;		struct rq *rq = cfs_rq->rq;
	int on_rq;		int on_rq;

	if (!shares)		spin_lock_irq(&rq->lock);
	shares = MIN_GROUP_SHARES;

	on_rq = se->on_rq;		on_rq = se->on_rq;
	if (on_rq) {		if (on_rq)
	dequeue_entity(cfs_rq, se, 0);		dequeue_entity(cfs_rq, se, 0);
	dec_cpu_load(rq, se->load.weight);
	}

	se->load.weight = shares;		se->load.weight = shares;
	se->load.inv_weight = div64_64((1ULL<<32), shares);		se->load.inv_weight = div64_64((1ULL<<32), shares);

	if (on_rq) {		if (on_rq)
	enqueue_entity(cfs_rq, se, 0);		enqueue_entity(cfs_rq, se, 0);
	inc_cpu_load(rq, se->load.weight);
	}		spin_unlock_irq(&rq->lock);
	}		}

	static DEFINE_MUTEX(shares_mutex);		static DEFINE_MUTEX(shares_mutex);
	@@ -7873,18 +7663,18 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
	int i;		int i;
	unsigned long flags;		unsigned long flags;

			/*
			* A weight of 0 or 1 can cause arithmetics problems.
			* (The default weight is 1024 - so there's no practical
			* limitation from this.)
			*/
			if (shares < 2)
			shares = 2;

	mutex_lock(&shares_mutex);		mutex_lock(&shares_mutex);
	if (tg->shares == shares)		if (tg->shares == shares)
	goto done;		goto done;

	if (shares < MIN_GROUP_SHARES)
	shares = MIN_GROUP_SHARES;

	/*
	* Prevent any load balance activity (rebalance_shares,
	* load_balance_fair) from referring to this group first,
	* by taking it off the rq->leaf_cfs_rq_list on each cpu.
	*/
	spin_lock_irqsave(&task_group_lock, flags);		spin_lock_irqsave(&task_group_lock, flags);
	for_each_possible_cpu(i)		for_each_possible_cpu(i)
	unregister_fair_sched_group(tg, i);		unregister_fair_sched_group(tg, i);
	@@ -7898,11 +7688,8 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
	* w/o tripping rebalance_share or load_balance_fair.		* w/o tripping rebalance_share or load_balance_fair.
	*/		*/
	tg->shares = shares;		tg->shares = shares;
	for_each_possible_cpu(i) {		for_each_possible_cpu(i)
	spin_lock_irq(&cpu_rq(i)->lock);
	set_se_shares(tg->se[i], shares);		set_se_shares(tg->se[i], shares);
	spin_unlock_irq(&cpu_rq(i)->lock);
	}

	/*		/*
	* Enable load balance activity on this group, by inserting it back on		* Enable load balance activity on this group, by inserting it back on

kernel/sched_fair.c

+35 −80

Original line number	Original line	Diff line number	Diff line
	@@ -727,8 +727,6 @@ static inline struct sched_entity parent_entity(struct sched_entity se)
	return se->parent;		return se->parent;
	}		}

	#define GROUP_IMBALANCE_PCT 20

	#else /* CONFIG_FAIR_GROUP_SCHED */		#else /* CONFIG_FAIR_GROUP_SCHED */

	#define for_each_sched_entity(se) \		#define for_each_sched_entity(se) \
	@@ -819,26 +817,15 @@ hrtick_start_fair(struct rq rq, struct task_struct p)
	static void enqueue_task_fair(struct rq rq, struct task_struct p, int wakeup)		static void enqueue_task_fair(struct rq rq, struct task_struct p, int wakeup)
	{		{
	struct cfs_rq *cfs_rq;		struct cfs_rq *cfs_rq;
	struct sched_entity *se = &p->se,		struct sched_entity *se = &p->se;
	topse = NULL; / Highest schedulable entity */
	int incload = 1;

	for_each_sched_entity(se) {		for_each_sched_entity(se) {
	topse = se;		if (se->on_rq)
	if (se->on_rq) {
	incload = 0;
	break;		break;
	}
	cfs_rq = cfs_rq_of(se);		cfs_rq = cfs_rq_of(se);
	enqueue_entity(cfs_rq, se, wakeup);		enqueue_entity(cfs_rq, se, wakeup);
	wakeup = 1;		wakeup = 1;
	}		}
	/* Increment cpu load if we just enqueued the first task of a group on
	* 'rq->cpu'. 'topse' represents the group to which task 'p' belongs
	* at the highest grouping level.
	*/
	if (incload)
	inc_cpu_load(rq, topse->load.weight);

	hrtick_start_fair(rq, rq->curr);		hrtick_start_fair(rq, rq->curr);
	}		}
	@@ -851,28 +838,16 @@ static void enqueue_task_fair(struct rq rq, struct task_struct p, int wakeup)
	static void dequeue_task_fair(struct rq rq, struct task_struct p, int sleep)		static void dequeue_task_fair(struct rq rq, struct task_struct p, int sleep)
	{		{
	struct cfs_rq *cfs_rq;		struct cfs_rq *cfs_rq;
	struct sched_entity *se = &p->se,		struct sched_entity *se = &p->se;
	topse = NULL; / Highest schedulable entity */
	int decload = 1;

	for_each_sched_entity(se) {		for_each_sched_entity(se) {
	topse = se;
	cfs_rq = cfs_rq_of(se);		cfs_rq = cfs_rq_of(se);
	dequeue_entity(cfs_rq, se, sleep);		dequeue_entity(cfs_rq, se, sleep);
	/* Don't dequeue parent if it has other entities besides us */		/* Don't dequeue parent if it has other entities besides us */
	if (cfs_rq->load.weight) {		if (cfs_rq->load.weight)
	if (parent_entity(se))
	decload = 0;
	break;		break;
	}
	sleep = 1;		sleep = 1;
	}		}
	/* Decrement cpu load if we just dequeued the last task of a group on
	* 'rq->cpu'. 'topse' represents the group to which task 'p' belongs
	* at the highest grouping level.
	*/
	if (decload)
	dec_cpu_load(rq, topse->load.weight);

	hrtick_start_fair(rq, rq->curr);		hrtick_start_fair(rq, rq->curr);
	}		}
	@@ -1186,6 +1161,25 @@ static struct task_struct load_balance_next_fair(void arg)
	return __load_balance_iterator(cfs_rq, cfs_rq->rb_load_balance_curr);		return __load_balance_iterator(cfs_rq, cfs_rq->rb_load_balance_curr);
	}		}

			#ifdef CONFIG_FAIR_GROUP_SCHED
			static int cfs_rq_best_prio(struct cfs_rq *cfs_rq)
			{
			struct sched_entity *curr;
			struct task_struct *p;

			if (!cfs_rq->nr_running \|\| !first_fair(cfs_rq))
			return MAX_PRIO;

			curr = cfs_rq->curr;
			if (!curr)
			curr = __pick_next_entity(cfs_rq);

			p = task_of(curr);

			return p->prio;
			}
			#endif

	static unsigned long		static unsigned long
	load_balance_fair(struct rq this_rq, int this_cpu, struct rq busiest,		load_balance_fair(struct rq this_rq, int this_cpu, struct rq busiest,
	unsigned long max_load_move,		unsigned long max_load_move,
	@@ -1195,45 +1189,28 @@ load_balance_fair(struct rq this_rq, int this_cpu, struct rq busiest,
	struct cfs_rq *busy_cfs_rq;		struct cfs_rq *busy_cfs_rq;
	long rem_load_move = max_load_move;		long rem_load_move = max_load_move;
	struct rq_iterator cfs_rq_iterator;		struct rq_iterator cfs_rq_iterator;
	unsigned long load_moved;

	cfs_rq_iterator.start = load_balance_start_fair;		cfs_rq_iterator.start = load_balance_start_fair;
	cfs_rq_iterator.next = load_balance_next_fair;		cfs_rq_iterator.next = load_balance_next_fair;

	for_each_leaf_cfs_rq(busiest, busy_cfs_rq) {		for_each_leaf_cfs_rq(busiest, busy_cfs_rq) {
	#ifdef CONFIG_FAIR_GROUP_SCHED		#ifdef CONFIG_FAIR_GROUP_SCHED
	struct cfs_rq *this_cfs_rq = busy_cfs_rq->tg->cfs_rq[this_cpu];		struct cfs_rq *this_cfs_rq;
	unsigned long maxload, task_load, group_weight;		long imbalance;
	unsigned long thisload, per_task_load;		unsigned long maxload;
	struct sched_entity *se = busy_cfs_rq->tg->se[busiest->cpu];

	task_load = busy_cfs_rq->load.weight;
	group_weight = se->load.weight;

	/*		this_cfs_rq = cpu_cfs_rq(busy_cfs_rq, this_cpu);
	* 'group_weight' is contributed by tasks of total weight
	* 'task_load'. To move 'rem_load_move' worth of weight only,
	* we need to move a maximum task load of:
	*
	* maxload = (remload / group_weight) * task_load;
	*/
	maxload = (rem_load_move * task_load) / group_weight;

	if (!maxload \|\| !task_load)		imbalance = busy_cfs_rq->load.weight - this_cfs_rq->load.weight;
			/* Don't pull if this_cfs_rq has more load than busy_cfs_rq */
			if (imbalance <= 0)
	continue;		continue;

	per_task_load = task_load / busy_cfs_rq->nr_running;		/* Don't pull more than imbalance/2 */
	/*		imbalance /= 2;
	* balance_tasks will try to forcibly move atleast one task if		maxload = min(rem_load_move, imbalance);
	* possible (because of SCHED_LOAD_SCALE_FUZZ). Avoid that if
	* maxload is less than GROUP_IMBALANCE_FUZZ% the per_task_load.
	*/
	if (100 * maxload < GROUP_IMBALANCE_PCT * per_task_load)
	continue;

	/* Disable priority-based load balance */		*this_best_prio = cfs_rq_best_prio(this_cfs_rq);
	*this_best_prio = 0;
	thisload = this_cfs_rq->load.weight;
	#else		#else
	# define maxload rem_load_move		# define maxload rem_load_move
	#endif		#endif
	@@ -1242,33 +1219,11 @@ load_balance_fair(struct rq this_rq, int this_cpu, struct rq busiest,
	* load_balance_[start\|next]_fair iterators		* load_balance_[start\|next]_fair iterators
	*/		*/
	cfs_rq_iterator.arg = busy_cfs_rq;		cfs_rq_iterator.arg = busy_cfs_rq;
	load_moved = balance_tasks(this_rq, this_cpu, busiest,		rem_load_move -= balance_tasks(this_rq, this_cpu, busiest,
	maxload, sd, idle, all_pinned,		maxload, sd, idle, all_pinned,
	this_best_prio,		this_best_prio,
	&cfs_rq_iterator);		&cfs_rq_iterator);

	#ifdef CONFIG_FAIR_GROUP_SCHED
	/*
	* load_moved holds the task load that was moved. The
	* effective (group) weight moved would be:
	* load_moved_eff = load_moved/task_load * group_weight;
	*/
	load_moved = (group_weight * load_moved) / task_load;

	/* Adjust shares on both cpus to reflect load_moved */
	group_weight -= load_moved;
	set_se_shares(se, group_weight);

	se = busy_cfs_rq->tg->se[this_cpu];
	if (!thisload)
	group_weight = load_moved;
	else
	group_weight = se->load.weight + load_moved;
	set_se_shares(se, group_weight);
	#endif

	rem_load_move -= load_moved;

	if (rem_load_move <= 0)		if (rem_load_move <= 0)
	break;		break;
	}		}

kernel/sched_rt.c

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -393,8 +393,6 @@ static void enqueue_task_rt(struct rq rq, struct task_struct p, int wakeup)
	*/		*/
	for_each_sched_rt_entity(rt_se)		for_each_sched_rt_entity(rt_se)
	enqueue_rt_entity(rt_se);		enqueue_rt_entity(rt_se);

	inc_cpu_load(rq, p->se.load.weight);
	}		}

	static void dequeue_task_rt(struct rq rq, struct task_struct p, int sleep)		static void dequeue_task_rt(struct rq rq, struct task_struct p, int sleep)
	@@ -414,8 +412,6 @@ static void dequeue_task_rt(struct rq rq, struct task_struct p, int sleep)
	if (rt_rq && rt_rq->rt_nr_running)		if (rt_rq && rt_rq->rt_nr_running)
	enqueue_rt_entity(rt_se);		enqueue_rt_entity(rt_se);
	}		}

	dec_cpu_load(rq, p->se.load.weight);
	}		}

	/*		/*

kernel/sysctl.c

+0 −18

Original line number	Original line	Diff line number	Diff line
	@@ -311,24 +311,6 @@ static struct ctl_table kern_table[] = {
	.mode = 0644,		.mode = 0644,
	.proc_handler = &proc_dointvec,		.proc_handler = &proc_dointvec,
	},		},
	#if defined(CONFIG_FAIR_GROUP_SCHED) && defined(CONFIG_SMP)
	{
	.ctl_name = CTL_UNNUMBERED,
	.procname = "sched_min_bal_int_shares",
	.data = &sysctl_sched_min_bal_int_shares,
	.maxlen = sizeof(unsigned int),
	.mode = 0644,
	.proc_handler = &proc_dointvec,
	},
	{
	.ctl_name = CTL_UNNUMBERED,
	.procname = "sched_max_bal_int_shares",
	.data = &sysctl_sched_max_bal_int_shares,
	.maxlen = sizeof(unsigned int),
	.mode = 0644,
	.proc_handler = &proc_dointvec,
	},
	#endif
	#endif		#endif
	{		{
	.ctl_name = CTL_UNNUMBERED,		.ctl_name = CTL_UNNUMBERED,