From f4d6ca5780a9a30bd08d3dd50b7107b6ecab6e23 Mon Sep 17 00:00:00 2001
From: alterego655 <824662526@qq.com>
Date: Fri, 24 Jul 2026 16:34:29 +0800
Subject: [PATCH v7 3/5] Avoid locking when an LSN waiter is already removed

WaitLSNWakeup() removes each selected waiter from its heap and clears
its inHeap flag before setting its latch.  When such a waiter later
calls deleteLSNWaiter(), it acquires WaitLSNLock exclusively only to
discover that there is nothing left to remove.  Waking many waiters can
therefore make them serialize on the lock for no useful work.

Check inHeap before acquiring WaitLSNLock.  A lockless false value is
conclusive because only the owning backend can change inHeap from false
to true.  A concurrent waker can only clear it.  A stale true value
falls through to the existing recheck under the lock.

WaitLSNCleanup() performed the same lockless check before calling
deleteLSNWaiter().  Drop it there, as it is now redundant.
---
 src/backend/access/transam/xlogwait.c | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/backend/access/transam/xlogwait.c b/src/backend/access/transam/xlogwait.c
index 85de3f5cdae..5ff1d4fcd70 100644
--- a/src/backend/access/transam/xlogwait.c
+++ b/src/backend/access/transam/xlogwait.c
@@ -252,6 +252,15 @@ deleteLSNWaiter(WaitLSNType lsnType)
 
 	Assert(i >= 0 && i < WAIT_LSN_TYPE_COUNT);
 
+	/*
+	 * Avoid taking WaitLSNLock if a waker has already removed us.  Only this
+	 * backend can set inHeap; other processes can only clear it.  Therefore
+	 * false is conclusive, while a stale true is harmless because it is
+	 * rechecked under WaitLSNLock below.
+	 */
+	if (!procInfo->inHeap)
+		return;
+
 	LWLockAcquire(WaitLSNLock, LW_EXCLUSIVE);
 
 	Assert(procInfo->lsnType == lsnType);
@@ -370,17 +379,15 @@ WaitLSNWakeup(WaitLSNType lsnType, XLogRecPtr currentLSN)
 void
 WaitLSNCleanup(void)
 {
+	/*
+	 * deleteLSNWaiter() starts with the same lockless inHeap check, so
+	 * calling it unconditionally costs nothing when this process isn't
+	 * waiting.  Its lsnType is then unused, and reading it is harmless in any
+	 * case: an entry that was never used is zeroed, which is a valid
+	 * WaitLSNType.
+	 */
 	if (waitLSNState)
-	{
-		/*
-		 * We do a fast-path check of the inHeap flag without the lock.  This
-		 * flag is set to true only by the process itself.  So, it's only
-		 * possible to get a false positive.  But that will be eliminated by a
-		 * recheck inside deleteLSNWaiter().
-		 */
-		if (waitLSNState->procInfos[MyProcNumber].inHeap)
-			deleteLSNWaiter(waitLSNState->procInfos[MyProcNumber].lsnType);
-	}
+		deleteLSNWaiter(waitLSNState->procInfos[MyProcNumber].lsnType);
 }
 
 /*
-- 
2.55.0