#include "postgres.h"
#include "access/xact.h"
#include "miscadmin.h"
#include "storage/proc.h"
#include "utils/xid8.h"

Include dependency graph for xid_wraparound.c:

Macros
#define	REPORT_INTERVAL (10 * 1000000)

#define	COMMIT_TS_XACTS_PER_PAGE (BLCKSZ / 10)

#define	SUBTRANS_XACTS_PER_PAGE (BLCKSZ / sizeof(TransactionId))

#define	CLOG_XACTS_PER_BYTE 4

#define	CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE)

Variables
	PG_MODULE_MAGIC

Macro Definition Documentation

◆ CLOG_XACTS_PER_BYTE

#define CLOG_XACTS_PER_BYTE 4

Definition at line 161 of file xid_wraparound.c.

◆ CLOG_XACTS_PER_PAGE

#define CLOG_XACTS_PER_PAGE (BLCKSZ * CLOG_XACTS_PER_BYTE)

Definition at line 162 of file xid_wraparound.c.

◆ COMMIT_TS_XACTS_PER_PAGE

#define COMMIT_TS_XACTS_PER_PAGE (BLCKSZ / 10)

Definition at line 159 of file xid_wraparound.c.

◆ REPORT_INTERVAL

#define REPORT_INTERVAL (10 * 1000000)

◆ SUBTRANS_XACTS_PER_PAGE

#define SUBTRANS_XACTS_PER_PAGE (BLCKSZ / sizeof(TransactionId))

Definition at line 160 of file xid_wraparound.c.

Function Documentation

◆ consume_xids()

Datum consume_xids ( PG_FUNCTION_ARGS )

Definition at line 32 of file xid_wraparound.c.

{
    int64       nxids = PG_GETARG_INT64(0);
    FullTransactionId lastxid;
 
    if (nxids < 0)
        elog(ERROR, "invalid nxids argument: %" PRId64, nxids);
 
    if (nxids == 0)
        lastxid = ReadNextFullTransactionId();
    else
        lastxid = consume_xids_common(InvalidFullTransactionId, (uint64) nxids);
 
    PG_RETURN_FULLTRANSACTIONID(lastxid);
}

References consume_xids_common(), elog, ERROR, fb(), InvalidFullTransactionId, PG_GETARG_INT64, PG_RETURN_FULLTRANSACTIONID, and ReadNextFullTransactionId().

◆ consume_xids_common()

static FullTransactionId consume_xids_common	(	FullTransactionId	untilxid,
		uint64	nxids
	)

static

Definition at line 71 of file xid_wraparound.c.

{
    FullTransactionId lastxid;
    uint64      last_reported_at = 0;
    uint64      consumed = 0;
 
    /* Print a NOTICE every REPORT_INTERVAL xids */
#define REPORT_INTERVAL (10 * 1000000)
 
    /* initialize 'lastxid' with the system's current next XID */
    lastxid = ReadNextFullTransactionId();
 
    /*
     * We consume XIDs by calling GetNewTransactionId(true), which marks the
     * consumed XIDs as subtransactions of the current top-level transaction.
     * For that to work, this transaction must have a top-level XID.
     *
     * GetNewTransactionId registers them in the subxid cache in PGPROC, until
     * the cache overflows, but beyond that, we don't keep track of the
     * consumed XIDs.
     */
    (void) GetTopTransactionId();
 
    for (;;)
    {
        uint64      xids_left;
 
        CHECK_FOR_INTERRUPTS();
 
        /* How many XIDs do we have left to consume? */
        if (nxids > 0)
        {
            if (consumed >= nxids)
                break;
            xids_left = nxids - consumed;
        }
        else
        {
            if (FullTransactionIdFollowsOrEquals(lastxid, untilxid))
                break;
            xids_left = U64FromFullTransactionId(untilxid) - U64FromFullTransactionId(lastxid);
        }
 
        /*
         * If we still have plenty of XIDs to consume, try to take a shortcut
         * and bump up the nextXid counter directly.
         */
        if (xids_left > 2000 &&
            consumed - last_reported_at < REPORT_INTERVAL &&
            MyProc->subxidStatus.overflowed)
        {
            int64       consumed_by_shortcut = consume_xids_shortcut();
 
            if (consumed_by_shortcut > 0)
            {
                consumed += consumed_by_shortcut;
                continue;
            }
        }
 
        /* Slow path: Call GetNewTransactionId to allocate a new XID. */
        lastxid = GetNewTransactionId(true);
        consumed++;
 
        /* Report progress */
        if (consumed - last_reported_at >= REPORT_INTERVAL)
        {
            if (nxids > 0)
                elog(NOTICE, "consumed %" PRIu64 " / %" PRIu64 " XIDs, latest %u:%u",
                     consumed, nxids,
                     EpochFromFullTransactionId(lastxid),
                     XidFromFullTransactionId(lastxid));
            else
                elog(NOTICE, "consumed up to %u:%u / %u:%u",
                     EpochFromFullTransactionId(lastxid),
                     XidFromFullTransactionId(lastxid),
                     EpochFromFullTransactionId(untilxid),
                     XidFromFullTransactionId(untilxid));
            last_reported_at = consumed;
        }
    }
 
    return lastxid;
}

References CHECK_FOR_INTERRUPTS, consume_xids_shortcut(), elog, EpochFromFullTransactionId, fb(), FullTransactionIdFollowsOrEquals, GetNewTransactionId(), GetTopTransactionId(), MyProc, NOTICE, XidCacheStatus::overflowed, ReadNextFullTransactionId(), REPORT_INTERVAL, PGPROC::subxidStatus, U64FromFullTransactionId, and XidFromFullTransactionId.

Referenced by consume_xids(), and consume_xids_until().

◆ consume_xids_shortcut()

static int64 consume_xids_shortcut ( void )

static

Definition at line 200 of file xid_wraparound.c.

{
    FullTransactionId nextXid;
    uint32      consumed;
 
    LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
    nextXid = TransamVariables->nextXid;
 
    /*
     * Go slow near the "interesting values". The interesting zones include 5
     * transactions before and after SLRU page switches.
     */
    consumed = XidSkip(nextXid);
    if (consumed > 0)
        TransamVariables->nextXid.value += (uint64) consumed;
 
    LWLockRelease(XidGenLock);
 
    return consumed;
}

References fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), TransamVariablesData::nextXid, TransamVariables, FullTransactionId::value, and XidSkip().

Referenced by consume_xids_common().

◆ consume_xids_until()

Datum consume_xids_until ( PG_FUNCTION_ARGS )

Definition at line 53 of file xid_wraparound.c.

{
    FullTransactionId targetxid = PG_GETARG_FULLTRANSACTIONID(0);
    FullTransactionId lastxid;
 
    if (!FullTransactionIdIsNormal(targetxid))
        elog(ERROR, "targetxid %" PRIu64 " is not normal",
             U64FromFullTransactionId(targetxid));
 
    lastxid = consume_xids_common(targetxid, 0);
 
    PG_RETURN_FULLTRANSACTIONID(lastxid);
}

References consume_xids_common(), elog, ERROR, fb(), FullTransactionIdIsNormal, PG_GETARG_FULLTRANSACTIONID, PG_RETURN_FULLTRANSACTIONID, and U64FromFullTransactionId.

◆ PG_FUNCTION_INFO_V1() [1/2]

PG_FUNCTION_INFO_V1 ( consume_xids )

◆ PG_FUNCTION_INFO_V1() [2/2]

PG_FUNCTION_INFO_V1 ( consume_xids_until )

◆ XidSkip()

static uint32 XidSkip ( FullTransactionId fullxid )

inlinestatic

Definition at line 171 of file xid_wraparound.c.

{
    uint32      low = XidFromFullTransactionId(fullxid);
    uint32      rem;
    uint32      distance;
 
    if (low < 5 || low >= UINT32_MAX - 5)
        return 0;
    distance = UINT32_MAX - 5 - low;
 
    rem = low % COMMIT_TS_XACTS_PER_PAGE;
    if (rem == 0)
        return 0;
    distance = Min(distance, COMMIT_TS_XACTS_PER_PAGE - rem);
 
    rem = low % SUBTRANS_XACTS_PER_PAGE;
    if (rem == 0)
        return 0;
    distance = Min(distance, SUBTRANS_XACTS_PER_PAGE - rem);
 
    rem = low % CLOG_XACTS_PER_PAGE;
    if (rem == 0)
        return 0;
    distance = Min(distance, CLOG_XACTS_PER_PAGE - rem);
 
    return distance;
}

References CLOG_XACTS_PER_PAGE, COMMIT_TS_XACTS_PER_PAGE, fb(), Min, SUBTRANS_XACTS_PER_PAGE, and XidFromFullTransactionId.

Referenced by consume_xids_shortcut().

Variable Documentation

◆ PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 22 of file xid_wraparound.c.

Functions
static int64	consume_xids_shortcut (void)

static FullTransactionId	consume_xids_common (FullTransactionId untilxid, uint64 nxids)

	PG_FUNCTION_INFO_V1 (consume_xids)

Datum	consume_xids (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (consume_xids_until)

Datum	consume_xids_until (PG_FUNCTION_ARGS)

static uint32	XidSkip (FullTransactionId fullxid)

Macros

Functions

Variables