From 21d6a6a12850724b53ebc240080a90597b3b2580 Mon Sep 17 00:00:00 2001 From: Simon Riggs Date: Sun, 18 Apr 2010 18:06:07 +0000 Subject: [PATCH] Tune GetSnapshotData() during Hot Standby by avoiding loop through normal backends. Makes code clearer also, since we avoid various Assert()s. Performance of snapshots taken during recovery no longer depends upon number of read-only backends. --- src/backend/access/transam/xlog.c | 8 +- src/backend/storage/ipc/procarray.c | 139 ++++++++++++++-------------- src/include/access/xlog.h | 3 +- 3 files changed, 79 insertions(+), 71 deletions(-) diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 9b6cd5253c..1cd5df5e7a 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $PostgreSQL: pgsql/src/backend/access/transam/xlog.c,v 1.397 2010/04/16 08:58:16 heikki Exp $ + * $PostgreSQL: pgsql/src/backend/access/transam/xlog.c,v 1.398 2010/04/18 18:05:51 sriggs Exp $ * *------------------------------------------------------------------------- */ @@ -6454,6 +6454,12 @@ CheckRecoveryConsistency(void) } } +bool +XLogConsistentState(void) +{ + return reachedMinRecoveryPoint; +} + /* * Is the system still in recovery? * diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index ac85d2fc29..c79f25ecf1 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -37,7 +37,7 @@ * * * IDENTIFICATION - * $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.62 2010/04/06 10:50:57 sriggs Exp $ + * $PostgreSQL: pgsql/src/backend/storage/ipc/procarray.c,v 1.63 2010/04/18 18:05:55 sriggs Exp $ * *------------------------------------------------------------------------- */ @@ -1091,89 +1091,90 @@ GetSnapshotData(Snapshot snapshot) globalxmin = xmin = xmax; /* - * Spin over procArray checking xid, xmin, and subxids. The goal is to - * gather all active xids, find the lowest xmin, and try to record - * subxids. + * If in recovery get any known assigned xids. */ - for (index = 0; index < arrayP->numProcs; index++) + if (!snapshot->takenDuringRecovery) { - volatile PGPROC *proc = arrayP->procs[index]; - TransactionId xid; - - /* Ignore procs running LAZY VACUUM */ - if (proc->vacuumFlags & PROC_IN_VACUUM) - continue; - - /* Update globalxmin to be the smallest valid xmin */ - xid = proc->xmin; /* fetch just once */ - if (TransactionIdIsNormal(xid) && - TransactionIdPrecedes(xid, globalxmin)) - globalxmin = xid; - - /* Fetch xid just once - see GetNewTransactionId */ - xid = proc->xid; - /* - * If the transaction has been assigned an xid < xmax we add it to the - * snapshot, and update xmin if necessary. There's no need to store - * XIDs >= xmax, since we'll treat them as running anyway. We don't - * bother to examine their subxids either. - * - * We don't include our own XID (if any) in the snapshot, but we must - * include it into xmin. + * Spin over procArray checking xid, xmin, and subxids. The goal is to + * gather all active xids, find the lowest xmin, and try to record + * subxids. During recovery no xids will be assigned, so all normal + * backends can be ignored, nor are there any VACUUMs running. All + * prepared transaction xids are held in KnownAssignedXids, so these + * will be seen without needing to loop through procs here. */ - if (TransactionIdIsNormal(xid)) + for (index = 0; index < arrayP->numProcs; index++) { - Assert(!snapshot->takenDuringRecovery); - if (TransactionIdFollowsOrEquals(xid, xmax)) + volatile PGPROC *proc = arrayP->procs[index]; + TransactionId xid; + + /* Ignore procs running LAZY VACUUM */ + if (proc->vacuumFlags & PROC_IN_VACUUM) continue; - if (proc != MyProc) - snapshot->xip[count++] = xid; - if (TransactionIdPrecedes(xid, xmin)) - xmin = xid; - } - /* - * Save subtransaction XIDs if possible (if we've already overflowed, - * there's no point). Note that the subxact XIDs must be later than - * their parent, so no need to check them against xmin. We could - * filter against xmax, but it seems better not to do that much work - * while holding the ProcArrayLock. - * - * The other backend can add more subxids concurrently, but cannot - * remove any. Hence it's important to fetch nxids just once. Should - * be safe to use memcpy, though. (We needn't worry about missing any - * xids added concurrently, because they must postdate xmax.) - * - * Again, our own XIDs are not included in the snapshot. - */ - if (!suboverflowed && proc != MyProc) - { - if (proc->subxids.overflowed) - suboverflowed = true; - else + /* Update globalxmin to be the smallest valid xmin */ + xid = proc->xmin; /* fetch just once */ + if (TransactionIdIsNormal(xid) && + TransactionIdPrecedes(xid, globalxmin)) + globalxmin = xid; + + /* Fetch xid just once - see GetNewTransactionId */ + xid = proc->xid; + + /* + * If the transaction has been assigned an xid < xmax we add it to the + * snapshot, and update xmin if necessary. There's no need to store + * XIDs >= xmax, since we'll treat them as running anyway. We don't + * bother to examine their subxids either. + * + * We don't include our own XID (if any) in the snapshot, but we must + * include it into xmin. + */ + if (TransactionIdIsNormal(xid)) { - int nxids = proc->subxids.nxids; + if (TransactionIdFollowsOrEquals(xid, xmax)) + continue; + if (proc != MyProc) + snapshot->xip[count++] = xid; + if (TransactionIdPrecedes(xid, xmin)) + xmin = xid; + } - if (nxids > 0) + /* + * Save subtransaction XIDs if possible (if we've already overflowed, + * there's no point). Note that the subxact XIDs must be later than + * their parent, so no need to check them against xmin. We could + * filter against xmax, but it seems better not to do that much work + * while holding the ProcArrayLock. + * + * The other backend can add more subxids concurrently, but cannot + * remove any. Hence it's important to fetch nxids just once. Should + * be safe to use memcpy, though. (We needn't worry about missing any + * xids added concurrently, because they must postdate xmax.) + * + * Again, our own XIDs are not included in the snapshot. + */ + if (!suboverflowed && proc != MyProc) + { + if (proc->subxids.overflowed) + suboverflowed = true; + else { - Assert(!snapshot->takenDuringRecovery); - memcpy(snapshot->subxip + subcount, - (void *) proc->subxids.xids, - nxids * sizeof(TransactionId)); - subcount += nxids; + int nxids = proc->subxids.nxids; + + if (nxids > 0) + { + memcpy(snapshot->subxip + subcount, + (void *) proc->subxids.xids, + nxids * sizeof(TransactionId)); + subcount += nxids; + } } } } } - - /* - * If in recovery get any known assigned xids. - */ - if (snapshot->takenDuringRecovery) + else { - Assert(count == 0); - /* * We store all xids directly into subxip[]. Here's why: * diff --git a/src/include/access/xlog.h b/src/include/access/xlog.h index de7406a808..f3db21ca43 100644 --- a/src/include/access/xlog.h +++ b/src/include/access/xlog.h @@ -6,7 +6,7 @@ * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * - * $PostgreSQL: pgsql/src/include/access/xlog.h,v 1.106 2010/04/12 09:52:29 heikki Exp $ + * $PostgreSQL: pgsql/src/include/access/xlog.h,v 1.107 2010/04/18 18:06:07 sriggs Exp $ */ #ifndef XLOG_H #define XLOG_H @@ -278,6 +278,7 @@ extern void xlog_desc(StringInfo buf, uint8 xl_info, char *rec); extern void issue_xlog_fsync(int fd, uint32 log, uint32 seg); +extern bool XLogConsistentState(void); extern bool RecoveryInProgress(void); extern bool XLogInsertAllowed(void); extern TimestampTz GetLatestXLogTime(void);