>From a3fb76c6a0982e7115dd0909aaccce4572bb7551 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 10 Dec 2012 12:08:30 +0100 Subject: [PATCH 12/19] wal_decodign: Log xl_running_xact's at a higher frequency than checkpoints are done Do so in the background writer which seems to be the best choice as its regularly running and shouldn't be busy for too long without getting back into its main loop. Also mark xl_standby records as being relevant for async commit so the wal writer writes them out soonish. This might also be beneficial for HS as it would make it faster to hit a spot where no (old) transactions are running anymroe. --- src/backend/postmaster/bgwriter.c | 47 +++++++++++++++++++++++++++++++++++++++ src/backend/storage/ipc/standby.c | 22 +++++++++++++++--- src/include/storage/standby.h | 2 +- 3 files changed, 67 insertions(+), 4 deletions(-) diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c index 286ae86..2adb36f 100644 --- 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" /* @@ -76,6 +78,10 @@ int BgWriterDelay = 200; static volatile sig_atomic_t got_SIGHUP = false; static volatile sig_atomic_t shutdown_requested = false; +static TimestampTz last_logged_snap_ts; +static XLogRecPtr last_logged_snap_recptr = InvalidXLogRecPtr; +static uint32 log_snap_interval_ms = 15000; + /* Signal handlers */ static void bg_quickdie(SIGNAL_ARGS); @@ -142,6 +148,12 @@ BackgroundWriterMain(void) CurrentResourceOwner = ResourceOwnerCreate(NULL, "Background Writer"); /* + * We just started, assume there has been either a shutdown or + * end-of-recovery snapshot. + */ + last_logged_snap_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 * possible memory leaks. Formerly this code just ran in @@ -276,6 +288,41 @@ BackgroundWriterMain(void) } /* + * Log a new xl_running_xacts every now and then so replication can get + * into a consistent state faster and clean up resources more + * frequently. The costs of this are relatively low, so doing it 4 + * times 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. + * + * 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 every in its + * mainloop. + */ + if (XLogStandbyInfoActive() && !RecoveryInProgress()) + { + TimestampTz timeout = 0; + timeout = TimestampTzPlusMilliseconds(last_logged_snap_ts, + log_snap_interval_ms); + + /* + * only log if enough time has passed and some xlog record has been + * inserted. + */ + if (GetCurrentTimestamp() >= timeout && + last_logged_snap_recptr != GetXLogInsertRecPtr()) + { + last_logged_snap_recptr = LogStandbySnapshot(); + last_logged_snap_ts = GetCurrentTimestamp(); + } + } + + /* * Sleep until we are signaled or BgWriterDelay has elapsed. * * Note: the feedback control loop in BgBufferSync() expects that we diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c index a903f12..deb1850 100644 --- 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); @@ -846,10 +846,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; @@ -875,8 +878,11 @@ LogStandbySnapshot(void) */ running = GetRunningTransactionData(); LogCurrentRunningXacts(running); + /* GetRunningTransactionData() acquired XidGenLock, we must release it */ LWLockRelease(XidGenLock); + + return recptr; } /* @@ -887,7 +893,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; @@ -937,6 +943,16 @@ LogCurrentRunningXacts(RunningTransactions CurrRunningXacts) CurrRunningXacts->oldestRunningXid, CurrRunningXacts->latestCompletedXid, CurrRunningXacts->nextXid); + + /* + * Ensure running xact information is synced to disk not too far in the + * future, logical standby's need this soon after initialization. We don't + * want to stall anything though, so we let the wal writer do it during + * normal operation. + */ + XLogSetAsyncXactLSN(recptr); + + return recptr; } /* diff --git a/src/include/storage/standby.h b/src/include/storage/standby.h index 168c14c..ab84584 100644 --- 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 */ -- 1.7.12.289.g0ce9864.dirty