Fix an issue in recent walwriter hibernation patch.

Users of asynchronous-commit mode expect there to be a guaranteed maximum
delay before an async commit's WAL records get flushed to disk.  The
original version of the walwriter hibernation patch broke that.  Add an
extra shared-memory flag to allow async commits to kick the walwriter out
of hibernation mode, without adding any noticeable overhead in cases where
no action is needed.

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 6d3a4cd3dfe2494ccb3bff704fe7838cc236599d..d3650bdf051e7d34a6d194c500ef4b01be64baf4 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -426,6 +426,13 @@ typedef struct XLogCtlData
     */
    bool        SharedHotStandbyActive;
 
+   /*
+    * WalWriterSleeping indicates whether the WAL writer is currently in
+    * low-power mode (and hence should be nudged if an async commit occurs).
+    * Protected by info_lck.
+    */
+   bool        WalWriterSleeping;
+
    /*
     * recoveryWakeupLatch is used to wake up the startup process to continue
     * WAL replay, if it is waiting for WAL to arrive or failover trigger file
@@ -1903,32 +1910,44 @@ XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch)
 
 /*
  * Record the LSN for an asynchronous transaction commit/abort
- * and nudge the WALWriter if there is a complete page to write.
+ * and nudge the WALWriter if there is work for it to do.
  * (This should not be called for synchronous commits.)
  */
 void
 XLogSetAsyncXactLSN(XLogRecPtr asyncXactLSN)
 {
    XLogRecPtr  WriteRqstPtr = asyncXactLSN;
+   bool        sleeping;
 
    /* use volatile pointer to prevent code rearrangement */
    volatile XLogCtlData *xlogctl = XLogCtl;
 
    SpinLockAcquire(&xlogctl->info_lck);
    LogwrtResult = xlogctl->LogwrtResult;
+   sleeping = xlogctl->WalWriterSleeping;
    if (XLByteLT(xlogctl->asyncXactLSN, asyncXactLSN))
        xlogctl->asyncXactLSN = asyncXactLSN;
    SpinLockRelease(&xlogctl->info_lck);
 
-   /* back off to last completed page boundary */
-   WriteRqstPtr.xrecoff -= WriteRqstPtr.xrecoff % XLOG_BLCKSZ;
+   /*
+    * If the WALWriter is sleeping, we should kick it to make it come out of
+    * low-power mode.  Otherwise, determine whether there's a full page of
+    * WAL available to write.
+    */
+   if (!sleeping)
+   {
+       /* back off to last completed page boundary */
+       WriteRqstPtr.xrecoff -= WriteRqstPtr.xrecoff % XLOG_BLCKSZ;
 
-   /* if we have already flushed that far, we're done */
-   if (XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
-       return;
+       /* if we have already flushed that far, we're done */
+       if (XLByteLE(WriteRqstPtr, LogwrtResult.Flush))
+           return;
+   }
 
    /*
-    * Nudge the WALWriter if we have a full page of WAL to write.
+    * Nudge the WALWriter: it has a full page of WAL to write, or we want
+    * it to come out of low-power mode so that this async commit will reach
+    * disk within the expected amount of time.
     */
    if (ProcGlobal->walwriterLatch)
        SetLatch(ProcGlobal->walwriterLatch);
@@ -5100,6 +5119,7 @@ XLOGShmemInit(void)
    XLogCtl->XLogCacheBlck = XLOGbuffers - 1;
    XLogCtl->SharedRecoveryInProgress = true;
    XLogCtl->SharedHotStandbyActive = false;
+   XLogCtl->WalWriterSleeping = false;
    XLogCtl->Insert.currpage = (XLogPageHeader) (XLogCtl->pages);
    SpinLockInit(&XLogCtl->info_lck);
    InitSharedLatch(&XLogCtl->recoveryWakeupLatch);
@@ -10479,3 +10499,17 @@ WakeupRecovery(void)
 {
    SetLatch(&XLogCtl->recoveryWakeupLatch);
 }
+
+/*
+ * Update the WalWriterSleeping flag.
+ */
+void
+SetWalWriterSleeping(bool sleeping)
+{
+   /* use volatile pointer to prevent code rearrangement */
+   volatile XLogCtlData *xlogctl = XLogCtl;
+
+   SpinLockAcquire(&xlogctl->info_lck);
+   xlogctl->WalWriterSleeping = sleeping;
+   SpinLockRelease(&xlogctl->info_lck);
+}

diff --git a/src/backend/postmaster/walwriter.c b/src/backend/postmaster/walwriter.c
index cd41dbbc8c3d3f9b7b0d8a8aba511806cbf752ec..733d01fd5b3249d13ee637d8e2d8ec68a4555faa 100644 (file)
--- a/src/backend/postmaster/walwriter.c
+++ b/src/backend/postmaster/walwriter.c
@@ -99,6 +99,7 @@ WalWriterMain(void)
    sigjmp_buf  local_sigjmp_buf;
    MemoryContext walwriter_context;
    int         left_till_hibernate;
+   bool        hibernating;
 
    /*
     * If possible, make this process a group leader, so that the postmaster
@@ -230,6 +231,8 @@ WalWriterMain(void)
     * Reset hibernation state after any error.
     */
    left_till_hibernate = LOOPS_UNTIL_HIBERNATE;
+   hibernating = false;
+   SetWalWriterSleeping(false);
 
    /*
     * Advertise our latch that backends can use to wake us up while we're
@@ -244,6 +247,21 @@ WalWriterMain(void)
    {
        long    cur_timeout;
 
+       /*
+        * Advertise whether we might hibernate in this cycle.  We do this
+        * before resetting the latch to ensure that any async commits will
+        * see the flag set if they might possibly need to wake us up, and
+        * that we won't miss any signal they send us.  (If we discover work
+        * to do in the last cycle before we would hibernate, the global flag
+        * will be set unnecessarily, but little harm is done.)  But avoid
+        * touching the global flag if it doesn't need to change.
+        */
+       if (hibernating != (left_till_hibernate <= 1))
+       {
+           hibernating = (left_till_hibernate <= 1);
+           SetWalWriterSleeping(hibernating);
+       }
+
        /* Clear any already-pending wakeups */
        ResetLatch(&MyProc->procLatch);
 

diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h
index 129712e7b9c9c8aa0e2554da698a0b893d3ff087..df5f232eeea44684b25ce81673b54e4ad47cc33c 100644 (file)
--- a/src/include/access/xlog.h
+++ b/src/include/access/xlog.h
@@ -316,6 +316,7 @@ extern TimeLineID GetRecoveryTargetTLI(void);
 
 extern bool CheckPromoteSignal(void);
 extern void WakeupRecovery(void);
+extern void SetWalWriterSleeping(bool sleeping);
 
 /*
  * Starting/stopping a base backup