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

Commit d1caeb02 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched 

* git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched:
  sched: fix startup penalty calculation
  sched: simplify bonus calculation #2
  sched: simplify bonus calculation #1
  sched: tidy up and simplify the bonus balance
  sched: optimize task_tick_rt() a bit
  sched: simplify can_migrate_task()
  sched: remove HZ dependency from the granularity default
  sched: CONFIG_SCHED_GROUP_FAIR=y fixlet
parents 37a3cc99 095e56c7

kernel/sched.c

+1 −7
Original line number Diff line number Diff line
@@ -2180,12 +2180,6 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu, 
	if (task_running(rq, p))

		return 0;



	/*

	 * Aggressive migration if too many balance attempts have failed:

	 */

	if (sd->nr_balance_failed > sd->cache_nice_tries)

		return 1;



	return 1;

}
@@ -4923,7 +4917,7 @@ static inline void sched_init_granularity(void) 
	if (sysctl_sched_granularity > gran_limit)

		sysctl_sched_granularity = gran_limit;



	sysctl_sched_runtime_limit = sysctl_sched_granularity * 8;

	sysctl_sched_runtime_limit = sysctl_sched_granularity * 5;

	sysctl_sched_wakeup_granularity = sysctl_sched_granularity / 2;

}

kernel/sched_fair.c

+19 −16
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 


/*

 * Preemption granularity:

 * (default: 2 msec, units: nanoseconds)

 * (default: 10 msec, units: nanoseconds)

 *

 * NOTE: this granularity value is not the same as the concept of

 * 'timeslice length' - timeslices in CFS will typically be somewhat
@@ -31,18 +31,17 @@ 
 * number of CPUs. (i.e. factor 2x on 2-way systems, 3x on 4-way

 * systems, 4x on 8-way systems, 5x on 16-way systems, etc.)

 */

unsigned int sysctl_sched_granularity __read_mostly = 2000000000ULL/HZ;

unsigned int sysctl_sched_granularity __read_mostly = 10000000UL;



/*

 * SCHED_BATCH wake-up granularity.

 * (default: 10 msec, units: nanoseconds)

 * (default: 25 msec, units: nanoseconds)

 *

 * This option delays the preemption effects of decoupled workloads

 * and reduces their over-scheduling. Synchronous workloads will still

 * have immediate wakeup/sleep latencies.

 */

unsigned int sysctl_sched_batch_wakeup_granularity __read_mostly =

							10000000000ULL/HZ;

unsigned int sysctl_sched_batch_wakeup_granularity __read_mostly = 25000000UL;



/*

 * SCHED_OTHER wake-up granularity.
@@ -52,12 +51,12 @@ unsigned int sysctl_sched_batch_wakeup_granularity __read_mostly = 
 * and reduces their over-scheduling. Synchronous workloads will still

 * have immediate wakeup/sleep latencies.

 */

unsigned int sysctl_sched_wakeup_granularity __read_mostly = 1000000000ULL/HZ;

unsigned int sysctl_sched_wakeup_granularity __read_mostly = 1000000UL;



unsigned int sysctl_sched_stat_granularity __read_mostly;



/*

 * Initialized in sched_init_granularity():

 * Initialized in sched_init_granularity() [to 5 times the base granularity]:

 */

unsigned int sysctl_sched_runtime_limit __read_mostly;
@@ -304,9 +303,9 @@ __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr) 
	delta_mine = calc_delta_mine(delta_exec, curr->load.weight, lw);



	if (cfs_rq->sleeper_bonus > sysctl_sched_granularity) {

		delta = min(cfs_rq->sleeper_bonus, (u64)delta_exec);

		delta = calc_delta_mine(delta, curr->load.weight, lw);

		delta = min((u64)delta, cfs_rq->sleeper_bonus);

		delta = min((u64)delta_mine, cfs_rq->sleeper_bonus);

		delta = min(delta, (unsigned long)(

			(long)sysctl_sched_runtime_limit - curr->wait_runtime));

		cfs_rq->sleeper_bonus -= delta;

		delta_mine -= delta;

	}
@@ -494,6 +493,13 @@ static void __enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se) 
	unsigned long load = cfs_rq->load.weight, delta_fair;

	long prev_runtime;



	/*

	 * Do not boost sleepers if there's too much bonus 'in flight'

	 * already:

	 */

	if (unlikely(cfs_rq->sleeper_bonus > sysctl_sched_runtime_limit))

		return;



	if (sysctl_sched_features & SCHED_FEAT_SLEEPER_LOAD_AVG)

		load = rq_of(cfs_rq)->cpu_load[2];
@@ -513,16 +519,13 @@ static void __enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se) 


	prev_runtime = se->wait_runtime;

	__add_wait_runtime(cfs_rq, se, delta_fair);

	schedstat_add(cfs_rq, wait_runtime, se->wait_runtime);

	delta_fair = se->wait_runtime - prev_runtime;



	/*

	 * Track the amount of bonus we've given to sleepers:

	 */

	cfs_rq->sleeper_bonus += delta_fair;

	if (unlikely(cfs_rq->sleeper_bonus > sysctl_sched_runtime_limit))

		cfs_rq->sleeper_bonus = sysctl_sched_runtime_limit;



	schedstat_add(cfs_rq, wait_runtime, se->wait_runtime);

}



static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
@@ -1044,7 +1047,7 @@ static void task_new_fair(struct rq *rq, struct task_struct *p) 
	 * -granularity/2, so initialize the task with that:

	 */

	if (sysctl_sched_features & SCHED_FEAT_START_DEBIT)

		p->se.wait_runtime = -(sysctl_sched_granularity / 2);

		p->se.wait_runtime = -((long)sysctl_sched_granularity / 2);



	__enqueue_entity(cfs_rq, se);

}
@@ -1057,7 +1060,7 @@ static void task_new_fair(struct rq *rq, struct task_struct *p) 
 */

static void set_curr_task_fair(struct rq *rq)

{

	struct sched_entity *se = &rq->curr.se;

	struct sched_entity *se = &rq->curr->se;



	for_each_sched_entity(se)

		set_next_entity(cfs_rq_of(se), se);

kernel/sched_rt.c

+8 −3
Original line number Diff line number Diff line
@@ -207,10 +207,15 @@ static void task_tick_rt(struct rq *rq, struct task_struct *p) 
		return;



	p->time_slice = static_prio_timeslice(p->static_prio);

	set_tsk_need_resched(p);



	/* put it at the end of the queue: */

	/*

	 * Requeue to the end of queue if we are not the only element

	 * on the queue:

	 */

	if (p->run_list.prev != p->run_list.next) {

		requeue_task_rt(rq, p);

		set_tsk_need_resched(p);

	}

}



static struct sched_class rt_sched_class __read_mostly = {