Commit 0b1777f0 authored by Tejun Heo's avatar Tejun Heo
Browse files

Merge branch 'tip/sched/core' into sched_ext/for-6.12 



Pull in tip/sched/core to resolve two merge conflicts:

- 96fd6c65 ("sched: Factor out update_other_load_avgs() from __update_blocked_others()")
  5d871a63 ("sched/fair: Move effective_cpu_util() and effective_cpu_util() in fair.c")

  A simple context conflict. The former added __update_blocked_others() in
  the same #ifdef CONFIG_SMP block that effective_cpu_util() and
  sched_cpu_util() are in and the latter moved those functions to fair.c.
  This makes __update_blocked_others() more out of place. Will follow up
  with a patch to relocate.

- 96fd6c65 ("sched: Factor out update_other_load_avgs() from __update_blocked_others()")
  84d26528 ("sched/pelt: Use rq_clock_task() for hw_pressure")

  The former factored out the body of __update_blocked_others() into
  update_other_load_avgs(). The latter changed how update_hw_load_avg() is
  called in the body. Resolved by applying the change to
  update_other_load_avgs() instead.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
parents 513ed0c7 bc9057da

Documentation/scheduler/sched-deadline.rst

+6 −8
Original line number Diff line number Diff line
@@ -749,21 +749,19 @@ Appendix A. Test suite 
 of the command line options. Please refer to rt-app documentation for more

 details (`<rt-app-sources>/doc/*.json`).



 The second testing application is a modification of schedtool, called

 schedtool-dl, which can be used to setup SCHED_DEADLINE parameters for a

 certain pid/application. schedtool-dl is available at:

 https://github.com/scheduler-tools/schedtool-dl.git.

 The second testing application is done using chrt which has support

 for SCHED_DEADLINE.



 The usage is straightforward::



  # schedtool -E -t 10000000:100000000 -e ./my_cpuhog_app

  # chrt -d -T 10000000 -D 100000000 0 ./my_cpuhog_app



 With this, my_cpuhog_app is put to run inside a SCHED_DEADLINE reservation

 of 10ms every 100ms (note that parameters are expressed in microseconds).

 You can also use schedtool to create a reservation for an already running

 of 10ms every 100ms (note that parameters are expressed in nanoseconds).

 You can also use chrt to create a reservation for an already running

 application, given that you know its pid::



  # schedtool -E -t 10000000:100000000 my_app_pid

  # chrt -d -T 10000000 -D 100000000 -p 0 my_app_pid



Appendix B. Minimal main()

==========================

drivers/cpufreq/cppc_cpufreq.c

+3 −3
Original line number Diff line number Diff line
@@ -224,9 +224,9 @@ static void __init cppc_freq_invariance_init(void) 
		 * Fake (unused) bandwidth; workaround to "fix"

		 * priority inheritance.

		 */

		.sched_runtime	= 1000000,

		.sched_deadline = 10000000,

		.sched_period	= 10000000,

		.sched_runtime	= NSEC_PER_MSEC,

		.sched_deadline = 10 * NSEC_PER_MSEC,

		.sched_period	= 10 * NSEC_PER_MSEC,

	};

	int ret;

include/uapi/linux/sched/types.h

+3 −3
Original line number Diff line number Diff line
@@ -58,9 +58,9 @@ 
 *

 * This is reflected by the following fields of the sched_attr structure:

 *

 *  @sched_deadline	representative of the task's deadline

 *  @sched_runtime	representative of the task's runtime

 *  @sched_period	representative of the task's period

 *  @sched_deadline	representative of the task's deadline in nanoseconds

 *  @sched_runtime	representative of the task's runtime in nanoseconds

 *  @sched_period	representative of the task's period in nanoseconds

 *

 * Given this task model, there are a multiplicity of scheduling algorithms

 * and policies, that can be used to ensure all the tasks will make their

kernel/kthread.c

+9 −1
Original line number Diff line number Diff line
@@ -845,8 +845,16 @@ int kthread_worker_fn(void *worker_ptr) 
		 * event only cares about the address.

		 */

		trace_sched_kthread_work_execute_end(work, func);

	} else if (!freezing(current))

	} else if (!freezing(current)) {

		schedule();

	} else {

		/*

		 * Handle the case where the current remains

		 * TASK_INTERRUPTIBLE. try_to_freeze() expects

		 * the current to be TASK_RUNNING.

		 */

		__set_current_state(TASK_RUNNING);

	}



	try_to_freeze();

	cond_resched();

kernel/sched/core.c

+32 −19
Original line number Diff line number Diff line
@@ -267,6 +267,9 @@ static inline int rb_sched_core_cmp(const void *key, const struct rb_node *node) 


void sched_core_enqueue(struct rq *rq, struct task_struct *p)

{

	if (p->se.sched_delayed)

		return;



	rq->core->core_task_seq++;



	if (!p->core_cookie)
@@ -277,6 +280,9 @@ void sched_core_enqueue(struct rq *rq, struct task_struct *p) 


void sched_core_dequeue(struct rq *rq, struct task_struct *p, int flags)

{

	if (p->se.sched_delayed)

		return;



	rq->core->core_task_seq++;



	if (sched_core_enqueued(p)) {
@@ -6477,19 +6483,12 @@ pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) 
 * Constants for the sched_mode argument of __schedule().

 *

 * The mode argument allows RT enabled kernels to differentiate a

 * preemption from blocking on an 'sleeping' spin/rwlock. Note that

 * SM_MASK_PREEMPT for !RT has all bits set, which allows the compiler to

 * optimize the AND operation out and just check for zero.

 * preemption from blocking on an 'sleeping' spin/rwlock.

 */

#define SM_NONE			0x0

#define SM_PREEMPT		0x1

#define SM_RTLOCK_WAIT		0x2



#ifndef CONFIG_PREEMPT_RT

# define SM_MASK_PREEMPT	(~0U)

#else

# define SM_MASK_PREEMPT	SM_PREEMPT

#endif

#define SM_IDLE			(-1)

#define SM_NONE			0

#define SM_PREEMPT		1

#define SM_RTLOCK_WAIT		2



/*

 * __schedule() is the main scheduler function.
@@ -6530,9 +6529,14 @@ pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) 
 *

 * WARNING: must be called with preemption disabled!

 */

static void __sched notrace __schedule(unsigned int sched_mode)

static void __sched notrace __schedule(int sched_mode)

{

	struct task_struct *prev, *next;

	/*

	 * On PREEMPT_RT kernel, SM_RTLOCK_WAIT is noted

	 * as a preemption by schedule_debug() and RCU.

	 */

	bool preempt = sched_mode > SM_NONE;

	unsigned long *switch_count;

	unsigned long prev_state;

	struct rq_flags rf;
@@ -6543,13 +6547,13 @@ static void __sched notrace __schedule(unsigned int sched_mode) 
	rq = cpu_rq(cpu);

	prev = rq->curr;



	schedule_debug(prev, !!sched_mode);

	schedule_debug(prev, preempt);



	if (sched_feat(HRTICK) || sched_feat(HRTICK_DL))

		hrtick_clear(rq);



	local_irq_disable();

	rcu_note_context_switch(!!sched_mode);

	rcu_note_context_switch(preempt);



	/*

	 * Make sure that signal_pending_state()->signal_pending() below
@@ -6578,12 +6582,20 @@ static void __sched notrace __schedule(unsigned int sched_mode) 


	switch_count = &prev->nivcsw;



	/* Task state changes only considers SM_PREEMPT as preemption */

	preempt = sched_mode == SM_PREEMPT;



	/*

	 * We must load prev->state once (task_struct::state is volatile), such

	 * that we form a control dependency vs deactivate_task() below.

	 */

	prev_state = READ_ONCE(prev->__state);

	if (!(sched_mode & SM_MASK_PREEMPT) && prev_state) {

	if (sched_mode == SM_IDLE) {

		if (!rq->nr_running) {

			next = prev;

			goto picked;

		}

	} else if (!preempt && prev_state) {

		if (signal_pending_state(prev_state, prev)) {

			WRITE_ONCE(prev->__state, TASK_RUNNING);

		} else {
@@ -6614,6 +6626,7 @@ static void __sched notrace __schedule(unsigned int sched_mode) 
	}



	next = pick_next_task(rq, prev, &rf);

picked:

	clear_tsk_need_resched(prev);

	clear_preempt_need_resched();

#ifdef CONFIG_SCHED_DEBUG
@@ -6655,7 +6668,7 @@ static void __sched notrace __schedule(unsigned int sched_mode) 
		psi_account_irqtime(rq, prev, next);

		psi_sched_switch(prev, next, !task_on_rq_queued(prev));



		trace_sched_switch(sched_mode & SM_MASK_PREEMPT, prev, next, prev_state);

		trace_sched_switch(preempt, prev, next, prev_state);



		/* Also unlocks the rq: */

		rq = context_switch(rq, prev, next, &rf);
@@ -6731,7 +6744,7 @@ static void sched_update_worker(struct task_struct *tsk) 
	}

}



static __always_inline void __schedule_loop(unsigned int sched_mode)

static __always_inline void __schedule_loop(int sched_mode)

{

	do {

		preempt_disable();
@@ -6776,7 +6789,7 @@ void __sched schedule_idle(void) 
	 */

	WARN_ON_ONCE(current->__state);

	do {

		__schedule(SM_NONE);

		__schedule(SM_IDLE);

	} while (need_resched());

}