database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-24 14:22:24 +03:00
Code Activity

pgindent run on access/transam/multixact.c

Browse Source 
This file has been patched over and over, and the differences to master
caused by pgindent are annoying enough that it seems saner to make the
older branches look the same.

Backpatch to 9.3, which is as far back as backpatching of bugfixes is
necessary.
This commit is contained in:
Alvaro Herrera
2015-06-04 15:20:28 -03:00
parent 290fb74794
commit b37f74868d
1 changed files with 26 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/backend/access/transam/multixact.c
View File

@ -970,7 +970,7 @@ GetNewMultiXactId(int nmembers, MultiXactOffset *offset)
*/ */
if (!MultiXactIdPrecedes(result, MultiXactState->multiVacLimit) || if (!MultiXactIdPrecedes(result, MultiXactState->multiVacLimit) ||
(MultiXactState->nextOffset - MultiXactState->oldestOffset (MultiXactState->nextOffset - MultiXactState->oldestOffset
> MULTIXACT_MEMBER_SAFE_THRESHOLD)) > MULTIXACT_MEMBER_SAFE_THRESHOLD))
{ {
/* /*
* For safety's sake, we release MultiXactGenLock while sending * For safety's sake, we release MultiXactGenLock while sending
@ -1194,14 +1194,14 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
* *
* An ID older than MultiXactState->oldestMultiXactId cannot possibly be * An ID older than MultiXactState->oldestMultiXactId cannot possibly be
* useful; it has already been removed, or will be removed shortly, by * useful; it has already been removed, or will be removed shortly, by
* truncation. Returning the wrong values could lead * truncation. Returning the wrong values could lead to an incorrect
* to an incorrect visibility result. However, to support pg_upgrade we * visibility result. However, to support pg_upgrade we need to allow an
* need to allow an empty set to be returned regardless, if the caller is * empty set to be returned regardless, if the caller is willing to accept
* willing to accept it; the caller is expected to check that it's an * it; the caller is expected to check that it's an allowed condition
* allowed condition (such as ensuring that the infomask bits set on the * (such as ensuring that the infomask bits set on the tuple are
* tuple are consistent with the pg_upgrade scenario). If the caller is * consistent with the pg_upgrade scenario). If the caller is expecting
* expecting this to be called only on recently created multis, then we * this to be called only on recently created multis, then we raise an
* raise an error. * error.
* *
* Conversely, an ID >= nextMXact shouldn't ever be seen here; if it is * Conversely, an ID >= nextMXact shouldn't ever be seen here; if it is
* seen, it implies undetected ID wraparound has occurred. This raises a * seen, it implies undetected ID wraparound has occurred. This raises a
@ -2142,11 +2142,11 @@ MultiXactSetNextMXact(MultiXactId nextMulti,
* enough to contain the next value that would be created. * enough to contain the next value that would be created.
* *
* We need to do this pretty early during the first startup in binary * We need to do this pretty early during the first startup in binary
* upgrade mode: before StartupMultiXact() in fact, because this routine is * upgrade mode: before StartupMultiXact() in fact, because this routine
* called even before that by StartupXLOG(). And we can't do it earlier * is called even before that by StartupXLOG(). And we can't do it
* than at this point, because during that first call of this routine we * earlier than at this point, because during that first call of this
* determine the MultiXactState->nextMXact value that MaybeExtendOffsetSlru * routine we determine the MultiXactState->nextMXact value that
* needs. * MaybeExtendOffsetSlru needs.
*/ */
if (IsBinaryUpgrade) if (IsBinaryUpgrade)
MaybeExtendOffsetSlru(); MaybeExtendOffsetSlru();
@ -2221,11 +2221,11 @@ SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid)
/* /*
* Determine the offset of the oldest multixact that might still be * Determine the offset of the oldest multixact that might still be
* referenced. Normally, we can read the offset from the multixact itself, * referenced. Normally, we can read the offset from the multixact
* but there's an important special case: if there are no multixacts in * itself, but there's an important special case: if there are no
* existence at all, oldest_datminmxid obviously can't point to one. It * multixacts in existence at all, oldest_datminmxid obviously can't point
* will instead point to the multixact ID that will be assigned the next * to one. It will instead point to the multixact ID that will be
* time one is needed. * assigned the next time one is needed.
* *
* NB: oldest_dataminmxid is the oldest multixact that might still be * NB: oldest_dataminmxid is the oldest multixact that might still be
* referenced from a table, unlike in DetermineSafeOldestOffset, where we * referenced from a table, unlike in DetermineSafeOldestOffset, where we
@ -2539,10 +2539,9 @@ DetermineSafeOldestOffset(MultiXactId oldestMXact)
* obviously can't point to one. It will instead point to the multixact * obviously can't point to one. It will instead point to the multixact
* ID that will be assigned the next time one is needed. * ID that will be assigned the next time one is needed.
* *
* NB: oldestMXact should be the oldest multixact that still exists in * NB: oldestMXact should be the oldest multixact that still exists in the
* the SLRU, unlike in SetMultiXactIdLimit, where we do this same * SLRU, unlike in SetMultiXactIdLimit, where we do this same computation
* computation based on the oldest value that might be referenced in a * based on the oldest value that might be referenced in a table.
* table.
*/ */
LWLockAcquire(MultiXactGenLock, LW_SHARED); LWLockAcquire(MultiXactGenLock, LW_SHARED);
if (MultiXactState->nextMXact == oldestMXact) if (MultiXactState->nextMXact == oldestMXact)
@ -2698,9 +2697,9 @@ int
MultiXactMemberFreezeThreshold(void) MultiXactMemberFreezeThreshold(void)
{ {
MultiXactOffset members; MultiXactOffset members;
uint32 multixacts; uint32 multixacts;
uint32 victim_multixacts; uint32 victim_multixacts;
double fraction; double fraction;
ReadMultiXactCounts(&multixacts, &members); ReadMultiXactCounts(&multixacts, &members);
@ -2819,7 +2818,7 @@ SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int segpage, void *data)
void void
TruncateMultiXact(void) TruncateMultiXact(void)
{ {
MultiXactId oldestMXact; MultiXactId oldestMXact;
MultiXactOffset oldestOffset; MultiXactOffset oldestOffset;
MultiXactOffset nextOffset; MultiXactOffset nextOffset;
mxtruncinfo trunc; mxtruncinfo trunc;
@ -2879,7 +2878,6 @@ TruncateMultiXact(void)
SimpleLruTruncate(MultiXactOffsetCtl, SimpleLruTruncate(MultiXactOffsetCtl,
MultiXactIdToOffsetPage(oldestMXact)); MultiXactIdToOffsetPage(oldestMXact));
/* /*
* Now, and only now, we can advance the stop point for multixact members. * Now, and only now, we can advance the stop point for multixact members.
* If we did it any sooner, the segments we deleted above might already * If we did it any sooner, the segments we deleted above might already