From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Mon, 15 Jun 2009 17:06:19 +0000 (-0700)
Subject: Merge branch 'timers-for-linus-migration' of git://git.kernel.org/pub/scm/linux/kerne... 
X-Git-Tag: 2.1b_release~12410
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=19035e5b5d1e3127b4925d86f6a77964f91f2c3c;p=platform%2Fkernel%2Fkernel-mfld-blackbay.git

Merge branch 'timers-for-linus-migration' of git://git./linux/kernel/git/tip/linux-2.6-tip

* 'timers-for-linus-migration' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  timers: Logic to move non pinned timers
  timers: /proc/sys sysctl hook to enable timer migration
  timers: Identifying the existing pinned timers
  timers: Framework for identifying pinned timers
  timers: allow deferrable timers for intervals tv2-tv5 to be deferred

Fix up conflicts in kernel/sched.c and kernel/timer.c manually
---

19035e5b5d1e3127b4925d86f6a77964f91f2c3c
diff --cc kernel/sched.c
index 8ec9d13,9fe3774..8fb88a9
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@@ -4397,121 -4244,11 +4397,126 @@@ static struct 
  	.load_balancer = ATOMIC_INIT(-1),
  };
  
+ int get_nohz_load_balancer(void)
+ {
+ 	return atomic_read(&nohz.load_balancer);
+ }
+ 
 +#if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
 +/**
 + * lowest_flag_domain - Return lowest sched_domain containing flag.
 + * @cpu:	The cpu whose lowest level of sched domain is to
 + *		be returned.
 + * @flag:	The flag to check for the lowest sched_domain
 + *		for the given cpu.
 + *
 + * Returns the lowest sched_domain of a cpu which contains the given flag.
 + */
 +static inline struct sched_domain *lowest_flag_domain(int cpu, int flag)
 +{
 +	struct sched_domain *sd;
 +
 +	for_each_domain(cpu, sd)
 +		if (sd && (sd->flags & flag))
 +			break;
 +
 +	return sd;
 +}
 +
 +/**
 + * for_each_flag_domain - Iterates over sched_domains containing the flag.
 + * @cpu:	The cpu whose domains we're iterating over.
 + * @sd:		variable holding the value of the power_savings_sd
 + *		for cpu.
 + * @flag:	The flag to filter the sched_domains to be iterated.
 + *
 + * Iterates over all the scheduler domains for a given cpu that has the 'flag'
 + * set, starting from the lowest sched_domain to the highest.
 + */
 +#define for_each_flag_domain(cpu, sd, flag) \
 +	for (sd = lowest_flag_domain(cpu, flag); \
 +		(sd && (sd->flags & flag)); sd = sd->parent)
 +
 +/**
 + * is_semi_idle_group - Checks if the given sched_group is semi-idle.
 + * @ilb_group:	group to be checked for semi-idleness
 + *
 + * Returns:	1 if the group is semi-idle. 0 otherwise.
 + *
 + * We define a sched_group to be semi idle if it has atleast one idle-CPU
 + * and atleast one non-idle CPU. This helper function checks if the given
 + * sched_group is semi-idle or not.
 + */
 +static inline int is_semi_idle_group(struct sched_group *ilb_group)
 +{
 +	cpumask_and(nohz.ilb_grp_nohz_mask, nohz.cpu_mask,
 +					sched_group_cpus(ilb_group));
 +
 +	/*
 +	 * A sched_group is semi-idle when it has atleast one busy cpu
 +	 * and atleast one idle cpu.
 +	 */
 +	if (cpumask_empty(nohz.ilb_grp_nohz_mask))
 +		return 0;
 +
 +	if (cpumask_equal(nohz.ilb_grp_nohz_mask, sched_group_cpus(ilb_group)))
 +		return 0;
 +
 +	return 1;
 +}
 +/**
 + * find_new_ilb - Finds the optimum idle load balancer for nomination.
 + * @cpu:	The cpu which is nominating a new idle_load_balancer.
 + *
 + * Returns:	Returns the id of the idle load balancer if it exists,
 + *		Else, returns >= nr_cpu_ids.
 + *
 + * This algorithm picks the idle load balancer such that it belongs to a
 + * semi-idle powersavings sched_domain. The idea is to try and avoid
 + * completely idle packages/cores just for the purpose of idle load balancing
 + * when there are other idle cpu's which are better suited for that job.
 + */
 +static int find_new_ilb(int cpu)
 +{
 +	struct sched_domain *sd;
 +	struct sched_group *ilb_group;
 +
 +	/*
 +	 * Have idle load balancer selection from semi-idle packages only
 +	 * when power-aware load balancing is enabled
 +	 */
 +	if (!(sched_smt_power_savings || sched_mc_power_savings))
 +		goto out_done;
 +
 +	/*
 +	 * Optimize for the case when we have no idle CPUs or only one
 +	 * idle CPU. Don't walk the sched_domain hierarchy in such cases
 +	 */
 +	if (cpumask_weight(nohz.cpu_mask) < 2)
 +		goto out_done;
 +
 +	for_each_flag_domain(cpu, sd, SD_POWERSAVINGS_BALANCE) {
 +		ilb_group = sd->groups;
 +
 +		do {
 +			if (is_semi_idle_group(ilb_group))
 +				return cpumask_first(nohz.ilb_grp_nohz_mask);
 +
 +			ilb_group = ilb_group->next;
 +
 +		} while (ilb_group != sd->groups);
 +	}
 +
 +out_done:
 +	return cpumask_first(nohz.cpu_mask);
 +}
 +#else /*  (CONFIG_SCHED_MC || CONFIG_SCHED_SMT) */
 +static inline int find_new_ilb(int call_cpu)
 +{
 +	return cpumask_first(nohz.cpu_mask);
 +}
 +#endif
 +
  /*
   * This routine will try to nominate the ilb (idle load balancing)
   * owner among the cpus whose ticks are stopped. ilb owner will do the idle
diff --cc kernel/timer.c
index faf2db8,3f841db..54d3912
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@@ -37,7 -37,7 +37,8 @@@
  #include <linux/delay.h>
  #include <linux/tick.h>
  #include <linux/kallsyms.h>
 +#include <linux/perf_counter.h>
+ #include <linux/sched.h>
  
  #include <asm/uaccess.h>
  #include <asm/unistd.h>