Merge git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched (a3ce8ea6) · Commits · e / devices / android_kernel_teracube_2e

include/linux/sched.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -1399,7 +1399,8 @@ static inline void idle_task_exit(void) {}

		extern void sched_idle_next(void);

		extern unsigned int sysctl_sched_granularity;
		extern unsigned int sysctl_sched_latency;
		extern unsigned int sysctl_sched_min_granularity;
		extern unsigned int sysctl_sched_wakeup_granularity;
		extern unsigned int sysctl_sched_batch_wakeup_granularity;
		extern unsigned int sysctl_sched_stat_granularity;

kernel/sched.c

+10 −6

Original line number	Diff line number	Diff line
		@@ -4911,14 +4911,18 @@ cpumask_t nohz_cpu_mask = CPU_MASK_NONE;
		static inline void sched_init_granularity(void)
		{
		unsigned int factor = 1 + ilog2(num_online_cpus());
		const unsigned long gran_limit = 100000000;
		const unsigned long limit = 100000000;

		sysctl_sched_granularity *= factor;
		if (sysctl_sched_granularity > gran_limit)
		sysctl_sched_granularity = gran_limit;
		sysctl_sched_min_granularity *= factor;
		if (sysctl_sched_min_granularity > limit)
		sysctl_sched_min_granularity = limit;

		sysctl_sched_runtime_limit = sysctl_sched_granularity * 5;
		sysctl_sched_wakeup_granularity = sysctl_sched_granularity / 2;
		sysctl_sched_latency *= factor;
		if (sysctl_sched_latency > limit)
		sysctl_sched_latency = limit;

		sysctl_sched_runtime_limit = sysctl_sched_latency * 5;
		sysctl_sched_wakeup_granularity = sysctl_sched_latency / 2;
		}

		#ifdef CONFIG_SMP

kernel/sched_fair.c

+65 −12

Original line number	Diff line number	Diff line
		@@ -15,23 +15,32 @@
		*
		* Scaled math optimizations by Thomas Gleixner
		* Copyright (C) 2007, Thomas Gleixner <tglx@linutronix.de>
		*
		* Adaptive scheduling granularity, math enhancements by Peter Zijlstra
		* Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
		*/

		/*
		* Preemption granularity:
		* (default: 10 msec, units: nanoseconds)
		* Targeted preemption latency for CPU-bound tasks:
		* (default: 20ms, units: nanoseconds)
		*
		* NOTE: this granularity value is not the same as the concept of
		* 'timeslice length' - timeslices in CFS will typically be somewhat
		* larger than this value. (to see the precise effective timeslice
		* length of your workload, run vmstat and monitor the context-switches
		* field)
		* NOTE: this latency value is not the same as the concept of
		* 'timeslice length' - timeslices in CFS are of variable length.
		* (to see the precise effective timeslice length of your workload,
		* run vmstat and monitor the context-switches field)
		*
		* On SMP systems the value of this is multiplied by the log2 of the
		* 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.)
		* Targeted preemption latency for CPU-bound tasks:
		*/
		unsigned int sysctl_sched_granularity __read_mostly = 10000000UL;
		unsigned int sysctl_sched_latency __read_mostly = 20000000ULL;

		/*
		* Minimal preemption granularity for CPU-bound tasks:
		* (default: 2 msec, units: nanoseconds)
		*/
		unsigned int sysctl_sched_min_granularity __read_mostly = 2000000ULL;

		/*
		* SCHED_BATCH wake-up granularity.
		@@ -212,6 +221,49 @@ static struct sched_entity __pick_next_entity(struct cfs_rq cfs_rq)
		* Scheduling class statistics methods:
		*/

		/*
		* Calculate the preemption granularity needed to schedule every
		* runnable task once per sysctl_sched_latency amount of time.
		* (down to a sensible low limit on granularity)
		*
		* For example, if there are 2 tasks running and latency is 10 msecs,
		* we switch tasks every 5 msecs. If we have 3 tasks running, we have
		* to switch tasks every 3.33 msecs to get a 10 msecs observed latency
		* for each task. We do finer and finer scheduling up to until we
		* reach the minimum granularity value.
		*
		* To achieve this we use the following dynamic-granularity rule:
		*
		* gran = lat/nr - lat/nr/nr
		*
		* This comes out of the following equations:
		*
		* kA1 + gran = kB1
		* kB2 + gran = kA2
		* kA2 = kA1
		* kB2 = kB1 - d + d/nr
		* lat = d * nr
		*
		* Where 'k' is key, 'A' is task A (waiting), 'B' is task B (running),
		* '1' is start of time, '2' is end of time, 'd' is delay between
		* 1 and 2 (during which task B was running), 'nr' is number of tasks
		* running, 'lat' is the the period of each task. ('lat' is the
		* sched_latency that we aim for.)
		*/
		static long
		sched_granularity(struct cfs_rq *cfs_rq)
		{
		unsigned int gran = sysctl_sched_latency;
		unsigned int nr = cfs_rq->nr_running;

		if (nr > 1) {
		gran = gran/nr - gran/nr/nr;
		gran = max(gran, sysctl_sched_min_granularity);
		}

		return gran;
		}

		/*
		* We rescale the rescheduling granularity of tasks according to their
		* nice level, but only linearly, not exponentially:
		@@ -302,7 +354,7 @@ __update_curr(struct cfs_rq cfs_rq, struct sched_entity curr)
		delta_fair = calc_delta_fair(delta_exec, lw);
		delta_mine = calc_delta_mine(delta_exec, curr->load.weight, lw);

		if (cfs_rq->sleeper_bonus > sysctl_sched_granularity) {
		if (cfs_rq->sleeper_bonus > sysctl_sched_latency) {
		delta = min((u64)delta_mine, cfs_rq->sleeper_bonus);
		delta = min(delta, (unsigned long)(
		(long)sysctl_sched_runtime_limit - curr->wait_runtime));
		@@ -689,7 +741,8 @@ static void entity_tick(struct cfs_rq cfs_rq, struct sched_entity curr)
		if (next == curr)
		return;

		__check_preempt_curr_fair(cfs_rq, next, curr, sysctl_sched_granularity);
		__check_preempt_curr_fair(cfs_rq, next, curr,
		sched_granularity(cfs_rq));
		}

		/**************************************************
		@@ -1034,7 +1087,7 @@ static void task_new_fair(struct rq rq, struct task_struct p)
		* it will preempt the parent:
		*/
		p->se.fair_key = current->se.fair_key -
		niced_granularity(&rq->curr->se, sysctl_sched_granularity) - 1;
		niced_granularity(&rq->curr->se, sched_granularity(cfs_rq)) - 1;
		/*
		* The first wait is dominated by the child-runs-first logic,
		* so do not credit it with that waiting time yet:
		@@ -1047,7 +1100,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 = -((long)sysctl_sched_granularity / 2);
		p->se.wait_runtime = -(sched_granularity(cfs_rq) / 2);

		__enqueue_entity(cfs_rq, se);
		}

kernel/sysctl.c

+22 −11

Original line number	Diff line number	Diff line
		@@ -222,8 +222,19 @@ static ctl_table kern_table[] = {
		#ifdef CONFIG_SCHED_DEBUG
		{
		.ctl_name = CTL_UNNUMBERED,
		.procname = "sched_granularity_ns",
		.data = &sysctl_sched_granularity,
		.procname = "sched_min_granularity_ns",
		.data = &sysctl_sched_min_granularity,
		.maxlen = sizeof(unsigned int),
		.mode = 0644,
		.proc_handler = &proc_dointvec_minmax,
		.strategy = &sysctl_intvec,
		.extra1 = &min_sched_granularity_ns,
		.extra2 = &max_sched_granularity_ns,
		},
		{
		.ctl_name = CTL_UNNUMBERED,
		.procname = "sched_latency_ns",
		.data = &sysctl_sched_latency,
		.maxlen = sizeof(unsigned int),
		.mode = 0644,
		.proc_handler = &proc_dointvec_minmax,
		@@ -283,6 +294,15 @@ static ctl_table kern_table[] = {
		.mode = 0644,
		.proc_handler = &proc_dointvec,
		},
		{
		.ctl_name = CTL_UNNUMBERED,
		.procname = "sched_features",
		.data = &sysctl_sched_features,
		.maxlen = sizeof(unsigned int),
		.mode = 0644,
		.proc_handler = &proc_dointvec,
		},
		#endif
		#ifdef CONFIG_PROVE_LOCKING
		{
		.ctl_name = CTL_UNNUMBERED,
		@@ -302,15 +322,6 @@ static ctl_table kern_table[] = {
		.mode = 0644,
		.proc_handler = &proc_dointvec,
		},
		#endif
		{
		.ctl_name = CTL_UNNUMBERED,
		.procname = "sched_features",
		.data = &sysctl_sched_features,
		.maxlen = sizeof(unsigned int),
		.mode = 0644,
		.proc_handler = &proc_dointvec,
		},
		#endif
		{
		.ctl_name = KERN_PANIC,