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

Commit b3e0b1b6 authored by Peter Zijlstra's avatar Peter Zijlstra Committed by Ingo Molnar
Browse files

locking, sched: Introduce smp_cond_acquire() and use it 



Introduce smp_cond_acquire() which combines a control dependency and a
read barrier to form acquire semantics.

This primitive has two benefits:

 - it documents control dependencies,
 - its typically cheaper than using smp_load_acquire() in a loop.

Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent 829cf317

include/linux/compiler.h

+17 −0
Original line number Diff line number Diff line
@@ -299,6 +299,23 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s 
	__u.__val;					\

})



/**

 * smp_cond_acquire() - Spin wait for cond with ACQUIRE ordering

 * @cond: boolean expression to wait for

 *

 * Equivalent to using smp_load_acquire() on the condition variable but employs

 * the control dependency of the wait to reduce the barrier on many platforms.

 *

 * The control dependency provides a LOAD->STORE order, the additional RMB

 * provides LOAD->LOAD order, together they provide LOAD->{LOAD,STORE} order,

 * aka. ACQUIRE.

 */

#define smp_cond_acquire(cond)	do {		\

	while (!(cond))				\

		cpu_relax();			\

	smp_rmb(); /* ctrl + rmb := acquire */	\

} while (0)



#endif /* __KERNEL__ */



#endif /* __ASSEMBLY__ */

kernel/locking/qspinlock.c

+1 −2
Original line number Diff line number Diff line
@@ -433,8 +433,7 @@ void queued_spin_lock_slowpath(struct qspinlock *lock, u32 val) 
	 *

	 */

	pv_wait_head(lock, node);

	while ((val = smp_load_acquire(&lock->val.counter)) & _Q_LOCKED_PENDING_MASK)

		cpu_relax();

	smp_cond_acquire(!((val = atomic_read(&lock->val)) & _Q_LOCKED_PENDING_MASK));



	/*

	 * claim the lock:

kernel/sched/core.c

+1 −7
Original line number Diff line number Diff line
@@ -1968,19 +1968,13 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags) 
	/*

	 * If the owning (remote) cpu is still in the middle of schedule() with

	 * this task as prev, wait until its done referencing the task.

	 */

	while (p->on_cpu)

		cpu_relax();

	/*

	 * Combined with the control dependency above, we have an effective

	 * smp_load_acquire() without the need for full barriers.

	 *

	 * Pairs with the smp_store_release() in finish_lock_switch().

	 *

	 * This ensures that tasks getting woken will be fully ordered against

	 * their previous state and preserve Program Order.

	 */

	smp_rmb();

	smp_cond_acquire(!p->on_cpu);



	p->sched_contributes_to_load = !!task_contributes_to_load(p);

	p->state = TASK_WAKING;

kernel/sched/sched.h

+1 −1
Original line number Diff line number Diff line
@@ -1076,7 +1076,7 @@ static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev) 
	 * In particular, the load of prev->state in finish_task_switch() must

	 * happen before this.

	 *

	 * Pairs with the control dependency and rmb in try_to_wake_up().

	 * Pairs with the smp_cond_acquire() in try_to_wake_up().

	 */

	smp_store_release(&prev->on_cpu, 0);

#endif