--- v3
+++ v1
@@ -1,12 +1,11 @@
-An over-committed guest with more vCPUs than pCPUs has a heavy overhead in
-osq_lock().
+An over-committed guest with more vCPUs than pCPUs has a heavy overload
+in osq_lock().
-This is because vCPU A hold the osq lock and yield out, vCPU B wait per_cpu
-node->locked to be set. IOW, vCPU B wait vCPU A to run and unlock the osq
-lock.
+This is because vCPU A hold the osq lock and yield out, vCPU B wait
+per_cpu node->locked to be set. IOW, vCPU B wait vCPU A to run and
+unlock the osq lock. Such spinning is meaningless.
-Kernel has an interface bool vcpu_is_preempted(int cpu) to see if a vCPU is
-currently running or not. So break the spin loops on true condition.
+So lets use vcpu_is_preempted() to detect if we need stop the spinning
test case:
perf record -a perf bench sched messaging -g 400 -p && perf report
@@ -29,14 +28,13 @@
2.64% sched-messaging [kernel.vmlinux] [k] rwsem_spin_on_owner
2.00% sched-messaging [kernel.vmlinux] [k] osq_lock
-Suggested-by: Boqun Feng <boqun.feng@gmail.com>
Signed-off-by: Pan Xinhui <xinhui.pan@linux.vnet.ibm.com>
---
- kernel/locking/osq_lock.c | 10 +++++++++-
- 1 file changed, 9 insertions(+), 1 deletion(-)
+ kernel/locking/osq_lock.c | 16 +++++++++++++++-
+ 1 file changed, 15 insertions(+), 1 deletion(-)
diff --git a/kernel/locking/osq_lock.c b/kernel/locking/osq_lock.c
-index 05a3785..858a0ed 100644
+index 05a3785..9e86f0b 100644
--- a/kernel/locking/osq_lock.c
+++ b/kernel/locking/osq_lock.c
@@ -21,6 +21,11 @@ static inline int encode_cpu(int cpu_nr)
@@ -51,16 +49,22 @@
static inline struct optimistic_spin_node *decode_cpu(int encoded_cpu_val)
{
int cpu_nr = encoded_cpu_val - 1;
-@@ -118,8 +123,11 @@ bool osq_lock(struct optimistic_spin_queue *lock)
+@@ -118,8 +123,17 @@ bool osq_lock(struct optimistic_spin_queue *lock)
while (!READ_ONCE(node->locked)) {
/*
* If we need to reschedule bail... so we can block.
-+ * Use vcpu_is_preempted to detech lock holder preemption issue
-+ * and break the loop. vcpu_is_preempted is a macro defined by
-+ * false if arch does not support vcpu preempted check,
++ * An over-committed guest with more vCPUs than pCPUs
++ * might fall in this loop and cause a huge overload.
++ * This is because vCPU A(prev) hold the osq lock and yield out
++ * vCPU B(node) wait ->locked to be set, IOW, it wait utill
++ * vCPU A run and unlock the osq lock. Such spin is meaningless
++ * use vcpu_is_preempted to detech such case. IF arch does not
++ * support vcpu preempted check, vcpu_is_preempted is a macro
++ * defined by false.
*/
- if (need_resched())
-+ if (need_resched() || vcpu_is_preempted(node_cpu(node->prev)))
++ if (need_resched() ||
++ vcpu_is_preempted(node_cpu(node->prev)))
goto unqueue;
cpu_relax_lowlatency();