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

Commit 7835b98b authored by Christoph Lameter's avatar Christoph Lameter Committed by Linus Torvalds
Browse files

[PATCH] sched: extract load calculation from rebalance_tick 



A load calculation is always done in rebalance_tick() in addition to the real
load balancing activities that only take place when certain jiffie counts have
been reached.  Move that processing into a separate function and call it
directly from scheduler_tick().

Also extract the time slice handling from scheduler_tick and put it into a
separate function.  Then we can clean up scheduler_tick significantly.  It
will no longer have any gotos.

Signed-off-by: default avatarChristoph Lameter <clameter@sgi.com>
Cc: Peter Williams <pwil3058@bigpond.net.au>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Cc: Christoph Lameter <clameter@sgi.com>
Cc: "Siddha, Suresh B" <suresh.b.siddha@intel.com>
Cc: "Chen, Kenneth W" <kenneth.w.chen@intel.com>
Acked-by: default avatarIngo Molnar <mingo@elte.hu>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent fe2eea3f

kernel/sched.c

+54 −42
Original line number Original line Diff line number Diff line
@@ -2833,20 +2833,9 @@ static void active_load_balance(struct rq *busiest_rq, int busiest_cpu) 
	spin_unlock(&target_rq->lock);

	spin_unlock(&target_rq->lock);

}

}





/*

static void update_load(struct rq *this_rq)

 * rebalance_tick will get called every timer tick, on every CPU.

 *

 * It checks each scheduling domain to see if it is due to be balanced,

 * and initiates a balancing operation if so.

 *

 * Balancing parameters are set up in arch_init_sched_domains.

 */



static void

rebalance_tick(int this_cpu, struct rq *this_rq, enum idle_type idle)

{

{

	unsigned long this_load, interval;

	unsigned long this_load;

	struct sched_domain *sd;

	int i, scale;

	int i, scale;





	this_load = this_rq->raw_weighted_load;

	this_load = this_rq->raw_weighted_load;
@@ -2866,6 +2855,22 @@ rebalance_tick(int this_cpu, struct rq *this_rq, enum idle_type idle) 
			new_load += scale-1;

			new_load += scale-1;

		this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) / scale;

		this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) / scale;

	}

	}

}



/*

 * rebalance_tick will get called every timer tick, on every CPU.

 *

 * It checks each scheduling domain to see if it is due to be balanced,

 * and initiates a balancing operation if so.

 *

 * Balancing parameters are set up in arch_init_sched_domains.

 */



static void

rebalance_tick(int this_cpu, struct rq *this_rq, enum idle_type idle)

{

	unsigned long interval;

	struct sched_domain *sd;





	for_each_domain(this_cpu, sd) {

	for_each_domain(this_cpu, sd) {

		if (!(sd->flags & SD_LOAD_BALANCE))

		if (!(sd->flags & SD_LOAD_BALANCE))
@@ -2897,12 +2902,15 @@ rebalance_tick(int this_cpu, struct rq *this_rq, enum idle_type idle) 
/*

/*

 * on UP we do not need to balance between CPUs:

 * on UP we do not need to balance between CPUs:

 */

 */

static inline void rebalance_tick(int cpu, struct rq *rq, enum idle_type idle)

static inline void rebalance_tick(int cpu, struct rq *rq)

{

{

}

}

static inline void idle_balance(int cpu, struct rq *rq)

static inline void idle_balance(int cpu, struct rq *rq)

{

{

}

}

static inline void update_load(struct rq *this_rq)

{

}

#endif

#endif





static inline int wake_priority_sleeper(struct rq *rq)

static inline int wake_priority_sleeper(struct rq *rq)
@@ -3052,35 +3060,12 @@ void account_steal_time(struct task_struct *p, cputime_t steal) 
		cpustat->steal = cputime64_add(cpustat->steal, tmp);

		cpustat->steal = cputime64_add(cpustat->steal, tmp);

}

}





/*

static void task_running_tick(struct rq *rq, struct task_struct *p)

 * This function gets called by the timer code, with HZ frequency.

 * We call it with interrupts disabled.

 *

 * It also gets called by the fork code, when changing the parent's

 * timeslices.

 */

void scheduler_tick(void)

{

{

	unsigned long long now = sched_clock();

	struct task_struct *p = current;

	int cpu = smp_processor_id();

	struct rq *rq = cpu_rq(cpu);



	update_cpu_clock(p, rq, now);



	rq->timestamp_last_tick = now;



	if (p == rq->idle) {

		if (wake_priority_sleeper(rq))

			goto out;

		rebalance_tick(cpu, rq, SCHED_IDLE);

		return;

	}



	/* Task might have expired already, but not scheduled off yet */

	if (p->array != rq->active) {

	if (p->array != rq->active) {

		/* Task has expired but was not scheduled yet */

		set_tsk_need_resched(p);

		set_tsk_need_resched(p);

		goto out;

		return;

	}

	}

	spin_lock(&rq->lock);

	spin_lock(&rq->lock);

	/*

	/*
@@ -3148,8 +3133,35 @@ void scheduler_tick(void) 
	}

	}

out_unlock:

out_unlock:

	spin_unlock(&rq->lock);

	spin_unlock(&rq->lock);

out:

}

	rebalance_tick(cpu, rq, NOT_IDLE);



/*

 * This function gets called by the timer code, with HZ frequency.

 * We call it with interrupts disabled.

 *

 * It also gets called by the fork code, when changing the parent's

 * timeslices.

 */

void scheduler_tick(void)

{

	unsigned long long now = sched_clock();

	struct task_struct *p = current;

	int cpu = smp_processor_id();

	struct rq *rq = cpu_rq(cpu);

	enum idle_type idle = NOT_IDLE;



	update_cpu_clock(p, rq, now);



	rq->timestamp_last_tick = now;



	if (p == rq->idle) {

		/* Task on the idle queue */

		if (!wake_priority_sleeper(rq))

			idle = SCHED_IDLE;

	} else

		task_running_tick(rq, p);

	update_load(rq);

	rebalance_tick(cpu, rq, idle);

}

}





#ifdef CONFIG_SCHED_SMT

#ifdef CONFIG_SCHED_SMT