Logging running transactions every 15 seconds.

Previously, we did this just once per checkpoint, but that could make
Hot Standby take a long time to initialize.  To avoid busying an
otherwise-idle system, we don't do this if no WAL has been written
since we did it last.

Andres Freund

diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c
index 6f5d937af9f4544b51d95e1b5c8f6df3f2034a22..1ec66c221fbd9dff5901a19d03a00382b78a6150 100644 (file)
--- a/src/backend/postmaster/bgwriter.c
+++ b/src/backend/postmaster/bgwriter.c
@@ -54,9 +54,11 @@
 #include "storage/shmem.h"
 #include "storage/smgr.h"
 #include "storage/spin.h"
+#include "storage/standby.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
 #include "utils/resowner.h"
+#include "utils/timestamp.h"
 
 
 /*
@@ -70,6 +72,20 @@ int                  BgWriterDelay = 200;
  */
 #define HIBERNATE_FACTOR                       50
 
+/*
+ * Interval in which standby snapshots are logged into the WAL stream, in
+ * milliseconds.
+ */
+#define LOG_SNAPSHOT_INTERVAL_MS 15000
+
+/*
+ * LSN and timestamp at which we last issued a LogStandbySnapshot(), to avoid
+ * doing so too often or repeatedly if there has been no other write activity
+ * in the system.
+ */
+static TimestampTz last_snapshot_ts;
+static XLogRecPtr last_snapshot_lsn = InvalidXLogRecPtr;
+
 /*
  * Flags set by interrupt handlers for later service in the main loop.
  */
@@ -141,6 +157,12 @@ BackgroundWriterMain(void)
         */
        CurrentResourceOwner = ResourceOwnerCreate(NULL, "Background Writer");
 
+       /*
+        * We just started, assume there has been either a shutdown or
+        * end-of-recovery snapshot.
+        */
+       last_snapshot_ts = GetCurrentTimestamp();
+
        /*
         * Create a memory context that we will do all our work in.  We do this so
         * that we can reset the context during error recovery and thereby avoid
@@ -275,6 +297,46 @@ BackgroundWriterMain(void)
                        smgrcloseall();
                }
 
+               /*
+                * Log a new xl_running_xacts every now and then so replication can get
+                * into a consistent state faster (think of suboverflowed snapshots)
+                * and clean up resources (locks, KnownXids*) more frequently. The
+                * costs of this are relatively low, so doing it 4 times
+                * (LOG_SNAPSHOT_INTERVAL_MS) a minute seems fine.
+                *
+                * We assume the interval for writing xl_running_xacts is
+                * significantly bigger than BgWriterDelay, so we don't complicate the
+                * overall timeout handling but just assume we're going to get called
+                * often enough even if hibernation mode is active. It's not that
+                * important that log_snap_interval_ms is met strictly. To make sure
+                * we're not waking the disk up unneccesarily on an idle system we
+                * check whether there has been any WAL inserted since the last time
+                * we've logged a running xacts.
+                *
+                * We do this logging in the bgwriter as its the only process thats
+                * run regularly and returns to its mainloop all the
+                * time. E.g. Checkpointer, when active, is barely ever in its
+                * mainloop and thus makes it hard to log regularly.
+                */
+               if (XLogStandbyInfoActive() && !RecoveryInProgress())
+               {
+                       TimestampTz timeout = 0;
+                       TimestampTz now = GetCurrentTimestamp();
+                       timeout = TimestampTzPlusMilliseconds(last_snapshot_ts,
+                                                                                                 LOG_SNAPSHOT_INTERVAL_MS);
+
+                       /*
+                        * only log if enough time has passed and some xlog record has been
+                        * inserted.
+                        */
+                       if (now >= timeout &&
+                               last_snapshot_lsn != GetXLogInsertRecPtr())
+                       {
+                               last_snapshot_lsn = LogStandbySnapshot();
+                               last_snapshot_ts = now;
+                       }
+               }
+
                /*
                 * Sleep until we are signaled or BgWriterDelay has elapsed.
                 *

diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
index 437d64b7873f5d89494f16de71741756660b703d..fb5f18edfc74b80142c4d40928675c267857396a 100644 (file)
--- a/src/backend/storage/ipc/standby.c
+++ b/src/backend/storage/ipc/standby.c
@@ -42,7 +42,7 @@ static void ResolveRecoveryConflictWithVirtualXIDs(VirtualTransactionId *waitlis
                                                                           ProcSignalReason reason);
 static void ResolveRecoveryConflictWithLock(Oid dbOid, Oid relOid);
 static void SendRecoveryConflictWithBufferPin(ProcSignalReason reason);
-static void LogCurrentRunningXacts(RunningTransactions CurrRunningXacts);
+static XLogRecPtr LogCurrentRunningXacts(RunningTransactions CurrRunningXacts);
 static void LogAccessExclusiveLocks(int nlocks, xl_standby_lock *locks);
 
 
@@ -853,10 +853,13 @@ standby_redo(XLogRecPtr lsn, XLogRecord *record)
  * currently running xids, performed by StandbyReleaseOldLocks().
  * Zero xids should no longer be possible, but we may be replaying WAL
  * from a time when they were possible.
+ *
+ * Returns the RecPtr of the last inserted record.
  */
-void
+XLogRecPtr
 LogStandbySnapshot(void)
 {
+       XLogRecPtr recptr;
        RunningTransactions running;
        xl_standby_lock *locks;
        int                     nlocks;
@@ -876,9 +879,12 @@ LogStandbySnapshot(void)
         * record we write, because standby will open up when it sees this.
         */
        running = GetRunningTransactionData();
-       LogCurrentRunningXacts(running);
+       recptr = LogCurrentRunningXacts(running);
+
        /* GetRunningTransactionData() acquired XidGenLock, we must release it */
        LWLockRelease(XidGenLock);
+
+       return recptr;
 }
 
 /*
@@ -889,7 +895,7 @@ LogStandbySnapshot(void)
  * is a contiguous chunk of memory and never exists fully until it is
  * assembled in WAL.
  */
-static void
+static XLogRecPtr
 LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
 {
        xl_running_xacts xlrec;
@@ -939,6 +945,19 @@ LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
                         CurrRunningXacts->oldestRunningXid,
                         CurrRunningXacts->latestCompletedXid,
                         CurrRunningXacts->nextXid);
+
+       /*
+        * Ensure running_xacts information is synced to disk not too far in the
+        * future. We don't want to stall anything though (i.e. use XLogFlush()),
+        * so we let the wal writer do it during normal
+        * operation. XLogSetAsyncXactLSN() conveniently will mark the LSN as
+        * to-be-synced and nudge the WALWriter into action if sleeping. Check
+        * XLogBackgroundFlush() for details why a record might not be flushed
+        * without it.
+        */
+       XLogSetAsyncXactLSN(recptr);
+
+       return recptr;
 }
 
 /*

diff --git a/src/include/storage/standby.h b/src/include/storage/standby.h
index 1eb10c454f2c5991c28e7dfd85b132146b51442a..89ab704699ba32dedca81d4d0ddfba6ef77f1318 100644 (file)
--- a/src/include/storage/standby.h
+++ b/src/include/storage/standby.h
@@ -113,6 +113,6 @@ typedef RunningTransactionsData *RunningTransactions;
 extern void LogAccessExclusiveLock(Oid dbOid, Oid relOid);
 extern void LogAccessExclusiveLockPrepare(void);
 
-extern void LogStandbySnapshot(void);
+extern XLogRecPtr LogStandbySnapshot(void);
 
 #endif   /* STANDBY_H */