Waiters spinning on the lock word should yield to the lock owner if the
vCPU is preempted. This improves performance when the hypervisor has
oversubscribed physical CPUs.
---
arch/powerpc/lib/qspinlock.c | 97 ++++++++++++++++++++++++++++++------
1 file changed, 83 insertions(+), 14 deletions(-)
diff --git a/arch/powerpc/lib/qspinlock.c b/arch/powerpc/lib/qspinlock.c
index aa26cfe21f18..55286ac91da5 100644
--- a/arch/powerpc/lib/qspinlock.c
+++ b/arch/powerpc/lib/qspinlock.c
@@ -5,6 +5,7 @@
#include <linux/percpu.h>
#include <linux/smp.h>
#include <asm/qspinlock.h>
+#include <asm/paravirt.h>
#define MAX_NODES 4
@@ -24,14 +25,16 @@ static int STEAL_SPINS __read_mostly = (1<<5);
static bool MAYBE_STEALERS __read_mostly = true;
static int HEAD_SPINS __read_mostly = (1<<8);
+static bool pv_yield_owner __read_mostly = true;
+
static DEFINE_PER_CPU_ALIGNED(struct qnodes, qnodes);
-static __always_inline int get_steal_spins(void)
+static __always_inline int get_steal_spins(bool paravirt)
{
return STEAL_SPINS;
}
-static __always_inline int get_head_spins(void)
+static __always_inline int get_head_spins(bool paravirt)
{
return HEAD_SPINS;
}
@@ -46,7 +49,11 @@ static inline int get_tail_cpu(u32 val)
return (val >> _Q_TAIL_CPU_OFFSET) - 1;
}
-/* Take the lock by setting the bit, no other CPUs may concurrently lock it. */
+static inline int get_owner_cpu(u32 val)
+{
+ return (val & _Q_OWNER_CPU_MASK) >> _Q_OWNER_CPU_OFFSET;
+}
+
/* Take the lock by setting the lock bit, no other CPUs will touch it. */
static __always_inline void lock_set_locked(struct qspinlock *lock)
{
@@ -180,7 +187,45 @@ static struct qnode *get_tail_qnode(struct qspinlock
*lock, u32 val)
BUG();
}
-static inline bool try_to_steal_lock(struct qspinlock *lock)
+static __always_inline void yield_to_locked_owner(struct qspinlock *lock, u32
val, bool paravirt)
+{
+ int owner;
+ u32 yield_count;
+
+ BUG_ON(!(val & _Q_LOCKED_VAL));
+
+ if (!paravirt)
+ goto relax;
+
+ if (!pv_yield_owner)
+ goto relax;
+
+ owner = get_owner_cpu(val);
+ yield_count = yield_count_of(owner);
+
+ if ((yield_count & 1) == 0)
+ goto relax; /* owner vcpu is running */
+
+ /*
+ * Read the lock word after sampling the yield count. On the other side
+ * there may a wmb because the yield count update is done by the
+ * hypervisor preemption and the value update by the OS, however this
+ * ordering might reduce the chance of out of order accesses and
+ * improve the heuristic.
+ */
+ smp_rmb();
+
+ if (READ_ONCE(lock->val) == val) {
+ yield_to_preempted(owner, yield_count);
+ /* Don't relax if we yielded. Maybe we should? */
+ return;
+ }
+relax:
+ cpu_relax();
+}
+
+
+static __always_inline bool try_to_steal_lock(struct qspinlock *lock, bool
paravirt)
{
int iters;
@@ -197,18 +242,18 @@ static inline bool try_to_steal_lock(struct qspinlock
*lock)
continue;
}
- cpu_relax();
+ yield_to_locked_owner(lock, val, paravirt);
iters++;
- if (iters >= get_steal_spins())
+ if (iters >= get_steal_spins(paravirt))
break;
}
return false;
}
-static inline void queued_spin_lock_mcs_queue(struct qspinlock *lock)
+static __always_inline void queued_spin_lock_mcs_queue(struct qspinlock *lock,
bool paravirt)
{
struct qnodes *qnodesp;
struct qnode *next, *node;
@@ -260,7 +305,7 @@ static inline void queued_spin_lock_mcs_queue(struct
qspinlock *lock)
if (!MAYBE_STEALERS) {
/* We're at the head of the waitqueue, wait for the lock. */
while ((val = READ_ONCE(lock->val)) & _Q_LOCKED_VAL)
- cpu_relax();
+ yield_to_locked_owner(lock, val, paravirt);
/* If we're the last queued, must clean up the tail. */
if ((val & _Q_TAIL_CPU_MASK) == tail) {
@@ -278,10 +323,10 @@ static inline void queued_spin_lock_mcs_queue(struct
qspinlock *lock)
again:
/* We're at the head of the waitqueue, wait for the lock. */
while ((val = READ_ONCE(lock->val)) & _Q_LOCKED_VAL) {
- cpu_relax();
+ yield_to_locked_owner(lock, val, paravirt);
iters++;
- if (!set_mustq && iters >= get_head_spins()) {
+ if (!set_mustq && iters >= get_head_spins(paravirt)) {
set_mustq = true;
lock_set_mustq(lock);
val |= _Q_MUST_Q_VAL;
@@ -320,10 +365,15 @@ static inline void queued_spin_lock_mcs_queue(struct
qspinlock *lock)
void queued_spin_lock_slowpath(struct qspinlock *lock)
{
- if (try_to_steal_lock(lock))
- return;
-
- queued_spin_lock_mcs_queue(lock);
+ if (IS_ENABLED(CONFIG_PARAVIRT_SPINLOCKS) && is_shared_processor()) {
+ if (try_to_steal_lock(lock, true))
+ return;
+ queued_spin_lock_mcs_queue(lock, true);
+ } else {
+ if (try_to_steal_lock(lock, false))
+ return;
+ queued_spin_lock_mcs_queue(lock, false);
+ }
}
EXPORT_SYMBOL(queued_spin_lock_slowpath);
@@ -382,10 +432,29 @@ static int head_spins_get(void *data, u64 *val)
DEFINE_SIMPLE_ATTRIBUTE(fops_head_spins, head_spins_get, head_spins_set,
"%llu\n");
+static int pv_yield_owner_set(void *data, u64 val)
+{
+ pv_yield_owner = !!val;
+
+ return 0;
+}
+
+static int pv_yield_owner_get(void *data, u64 *val)
+{
+ *val = pv_yield_owner;
+
+ return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_pv_yield_owner, pv_yield_owner_get,
pv_yield_owner_set, "%llu\n");
+
static __init int spinlock_debugfs_init(void)
{
debugfs_create_file("qspl_steal_spins", 0600, arch_debugfs_dir, NULL,
&fops_steal_spins);
debugfs_create_file("qspl_head_spins", 0600, arch_debugfs_dir, NULL,
&fops_head_spins);
+ if (is_shared_processor()) {
+ debugfs_create_file("qspl_pv_yield_owner", 0600,
arch_debugfs_dir, NULL, &fops_pv_yield_owner);
+ }
return 0;
}
--
2.35.1
