vacuumlazy.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/amapi.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/heapam_xlog.h"
#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/parallel.h"
#include "access/transam.h"
#include "access/visibilitymap.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/storage.h"
#include "commands/dbcommands.h"
#include "commands/progress.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
#include "optimizer/paths.h"
#include "pgstat.h"
#include "portability/instr_time.h"
#include "postmaster/autovacuum.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
#include "storage/lmgr.h"
#include "tcop/tcopprot.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/pg_rusage.h"
#include "utils/timestamp.h"

Include dependency graph for vacuumlazy.c:

Go to the source code of this file.

Data Structures
struct	LVDeadTuples
struct	LVShared
struct	LVSharedIndStats
struct	LVParallelState
struct	LVRelStats

Macros
#define	REL_TRUNCATE_MINIMUM   1000
#define	REL_TRUNCATE_FRACTION   16
#define	VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL   20 /* ms */
#define	VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL   50 /* ms */
#define	VACUUM_TRUNCATE_LOCK_TIMEOUT   5000 /* ms */
#define	VACUUM_FSM_EVERY_PAGES   ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ))
#define	LAZY_ALLOC_TUPLES   MaxHeapTuplesPerPage
#define	SKIP_PAGES_THRESHOLD   ((BlockNumber) 32)
#define	PREFETCH_SIZE   ((BlockNumber) 32)
#define	PARALLEL_VACUUM_KEY_SHARED   1
#define	PARALLEL_VACUUM_KEY_DEAD_TUPLES   2
#define	PARALLEL_VACUUM_KEY_QUERY_TEXT   3
#define	ParallelVacuumIsActive(lps)   PointerIsValid(lps)
#define	SizeOfDeadTuples(cnt)
#define	MAXDEADTUPLES(max_size)   (((max_size) - offsetof(LVDeadTuples, itemptrs)) / sizeof(ItemPointerData))
#define	SizeOfLVShared   (offsetof(LVShared, bitmap) + sizeof(bits8))
#define	GetSharedIndStats(s)   ((LVSharedIndStats *)((char *)(s) + ((LVShared *)(s))->offset))
#define	IndStatsIsNull(s, i)   (!(((LVShared *)(s))->bitmap[(i) >> 3] & (1 << ((i) & 0x07))))
#define	FORCE_CHECK_PAGE()   (blkno == nblocks - 1 && should_attempt_truncation(params, vacrelstats))

Typedefs
typedef struct LVDeadTuples	LVDeadTuples
typedef struct LVShared	LVShared
typedef struct LVSharedIndStats	LVSharedIndStats
typedef struct LVParallelState	LVParallelState
typedef struct LVRelStats	LVRelStats

Functions
static void	lazy_scan_heap (Relation onerel, VacuumParams *params, LVRelStats *vacrelstats, Relation *Irel, int nindexes, bool aggressive)
static void	lazy_vacuum_heap (Relation onerel, LVRelStats *vacrelstats)
static bool	lazy_check_needs_freeze (Buffer buf, bool *hastup)
static void	lazy_vacuum_all_indexes (Relation onerel, Relation *Irel, IndexBulkDeleteResult **stats, LVRelStats *vacrelstats, LVParallelState *lps, int nindexes)
static void	lazy_vacuum_index (Relation indrel, IndexBulkDeleteResult **stats, LVDeadTuples *dead_tuples, double reltuples)
static void	lazy_cleanup_index (Relation indrel, IndexBulkDeleteResult **stats, double reltuples, bool estimated_count)
static int	lazy_vacuum_page (Relation onerel, BlockNumber blkno, Buffer buffer, int tupindex, LVRelStats *vacrelstats, Buffer *vmbuffer)
static bool	should_attempt_truncation (VacuumParams *params, LVRelStats *vacrelstats)
static void	lazy_truncate_heap (Relation onerel, LVRelStats *vacrelstats)
static BlockNumber	count_nondeletable_pages (Relation onerel, LVRelStats *vacrelstats)
static void	lazy_space_alloc (LVRelStats *vacrelstats, BlockNumber relblocks)
static void	lazy_record_dead_tuple (LVDeadTuples *dead_tuples, ItemPointer itemptr)
static bool	lazy_tid_reaped (ItemPointer itemptr, void *state)
static int	vac_cmp_itemptr (const void *left, const void *right)
static bool	heap_page_is_all_visible (Relation rel, Buffer buf, TransactionId *visibility_cutoff_xid, bool *all_frozen)
static void	lazy_parallel_vacuum_indexes (Relation *Irel, IndexBulkDeleteResult **stats, LVRelStats *vacrelstats, LVParallelState *lps, int nindexes)
static void	parallel_vacuum_index (Relation *Irel, IndexBulkDeleteResult **stats, LVShared *lvshared, LVDeadTuples *dead_tuples, int nindexes)
static void	vacuum_indexes_leader (Relation *Irel, IndexBulkDeleteResult **stats, LVRelStats *vacrelstats, LVParallelState *lps, int nindexes)
static void	vacuum_one_index (Relation indrel, IndexBulkDeleteResult **stats, LVShared *lvshared, LVSharedIndStats *shared_indstats, LVDeadTuples *dead_tuples)
static void	lazy_cleanup_all_indexes (Relation *Irel, IndexBulkDeleteResult **stats, LVRelStats *vacrelstats, LVParallelState *lps, int nindexes)
static long	compute_max_dead_tuples (BlockNumber relblocks, bool hasindex)
static int	compute_parallel_vacuum_workers (Relation *Irel, int nindexes, int nrequested, bool *can_parallel_vacuum)
static void	prepare_index_statistics (LVShared *lvshared, bool *can_parallel_vacuum, int nindexes)
static void	update_index_statistics (Relation *Irel, IndexBulkDeleteResult **stats, int nindexes)
static LVParallelState *	begin_parallel_vacuum (Oid relid, Relation *Irel, LVRelStats *vacrelstats, BlockNumber nblocks, int nindexes, int nrequested)
static void	end_parallel_vacuum (Relation *Irel, IndexBulkDeleteResult **stats, LVParallelState *lps, int nindexes)
static LVSharedIndStats *	get_indstats (LVShared *lvshared, int n)
static bool	skip_parallel_vacuum_index (Relation indrel, LVShared *lvshared)
void	heap_vacuum_rel (Relation onerel, VacuumParams *params, BufferAccessStrategy bstrategy)
static void	vacuum_log_cleanup_info (Relation rel, LVRelStats *vacrelstats)
void	parallel_vacuum_main (dsm_segment *seg, shm_toc *toc)

Variables
static int	elevel = -1
static TransactionId	OldestXmin
static TransactionId	FreezeLimit
static MultiXactId	MultiXactCutoff
static BufferAccessStrategy	vac_strategy

Macro Definition Documentation

FORCE_CHECK_PAGE

#define FORCE_CHECK_PAGE

(

)

(blkno == nblocks - 1 && should_attempt_truncation(params, vacrelstats))

Referenced by lazy_scan_heap().

GetSharedIndStats

#define GetSharedIndStats

(

s

)

((LVSharedIndStats *)((char *)(s) + ((LVShared *)(s))->offset))

Definition at line 239 of file vacuumlazy.c.

Referenced by get_indstats().

IndStatsIsNull

#define IndStatsIsNull	(		s,
			i
	)		(!(((LVShared *)(s))->bitmap[(i) >> 3] & (1 << ((i) & 0x07))))

Definition at line 241 of file vacuumlazy.c.

Referenced by get_indstats().

LAZY_ALLOC_TUPLES

#define LAZY_ALLOC_TUPLES   MaxHeapTuplesPerPage

Definition at line 118 of file vacuumlazy.c.

Referenced by compute_max_dead_tuples().

MAXDEADTUPLES

#define MAXDEADTUPLES

(

max_size

)

(((max_size) - offsetof(LVDeadTuples, itemptrs)) / sizeof(ItemPointerData))

Definition at line 166 of file vacuumlazy.c.

Referenced by compute_max_dead_tuples().

PARALLEL_VACUUM_KEY_DEAD_TUPLES

#define PARALLEL_VACUUM_KEY_DEAD_TUPLES   2

Definition at line 138 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and parallel_vacuum_main().

PARALLEL_VACUUM_KEY_QUERY_TEXT

#define PARALLEL_VACUUM_KEY_QUERY_TEXT   3

Definition at line 139 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and parallel_vacuum_main().

PARALLEL_VACUUM_KEY_SHARED

#define PARALLEL_VACUUM_KEY_SHARED   1

Definition at line 137 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and parallel_vacuum_main().

ParallelVacuumIsActive

#define ParallelVacuumIsActive

(

lps

)

PointerIsValid(lps)

Definition at line 145 of file vacuumlazy.c.

Referenced by lazy_cleanup_all_indexes(), lazy_parallel_vacuum_indexes(), lazy_scan_heap(), and lazy_vacuum_all_indexes().

PREFETCH_SIZE

#define PREFETCH_SIZE   ((BlockNumber) 32)

Definition at line 130 of file vacuumlazy.c.

Referenced by count_nondeletable_pages().

REL_TRUNCATE_FRACTION

#define REL_TRUNCATE_FRACTION   16

Definition at line 91 of file vacuumlazy.c.

Referenced by should_attempt_truncation().

REL_TRUNCATE_MINIMUM

#define REL_TRUNCATE_MINIMUM   1000

Definition at line 90 of file vacuumlazy.c.

Referenced by should_attempt_truncation().

SizeOfDeadTuples

#define SizeOfDeadTuples

(

cnt

)

Value:

add_size(offsetof(LVDeadTuples, itemptrs), \
             mul_size(sizeof(ItemPointerData), cnt))

Definition at line 163 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and lazy_space_alloc().

SizeOfLVShared

#define SizeOfLVShared   (offsetof(LVShared, bitmap) + sizeof(bits8))

Definition at line 238 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum().

SKIP_PAGES_THRESHOLD

#define SKIP_PAGES_THRESHOLD   ((BlockNumber) 32)

Definition at line 124 of file vacuumlazy.c.

Referenced by lazy_scan_heap().

VACUUM_FSM_EVERY_PAGES

#define VACUUM_FSM_EVERY_PAGES   ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ))

Definition at line 110 of file vacuumlazy.c.

Referenced by lazy_scan_heap().

VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL

#define VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL   20 /* ms */

Definition at line 100 of file vacuumlazy.c.

Referenced by count_nondeletable_pages().

VACUUM_TRUNCATE_LOCK_TIMEOUT

#define VACUUM_TRUNCATE_LOCK_TIMEOUT   5000 /* ms */

Definition at line 102 of file vacuumlazy.c.

Referenced by lazy_truncate_heap().

VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL

#define VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL   50 /* ms */

Definition at line 101 of file vacuumlazy.c.

Referenced by lazy_truncate_heap().

Typedef Documentation

LVDeadTuples

typedef struct LVDeadTuples LVDeadTuples

LVParallelState

typedef struct LVParallelState LVParallelState

LVRelStats

typedef struct LVRelStats LVRelStats

LVShared

typedef struct LVShared LVShared

LVSharedIndStats

typedef struct LVSharedIndStats LVSharedIndStats

Function Documentation

begin_parallel_vacuum()

static LVParallelState * begin_parallel_vacuum ( Oid  relid, Relation *  Irel, LVRelStats *  vacrelstats, BlockNumber  nblocks, int  nindexes, int  nrequested  )

static

Definition at line 3067 of file vacuumlazy.c.

References LVShared::active_nworkers, add_size(), IndexAmRoutine::amparallelvacuumoptions, Assert, BITMAPLEN, compute_max_dead_tuples(), compute_parallel_vacuum_workers(), LVShared::cost_balance, CreateParallelContext(), LVRelStats::dead_tuples, debug_query_string, LVShared::elevel, elevel, EnterParallelMode(), ParallelContext::estimator, i, LVShared::idx, InitializeParallelDSM(), LVDeadTuples::itemptrs, LVParallelState::lvshared, maintenance_work_mem, LVShared::maintenance_work_mem_worker, LVDeadTuples::max_tuples, MAXALIGN, MemSet, Min, LVParallelState::nindexes_parallel_bulkdel, LVParallelState::nindexes_parallel_cleanup, LVParallelState::nindexes_parallel_condcleanup, LVDeadTuples::num_tuples, ParallelContext::nworkers, LVShared::offset, palloc0(), PARALLEL_VACUUM_KEY_DEAD_TUPLES, PARALLEL_VACUUM_KEY_QUERY_TEXT, PARALLEL_VACUUM_KEY_SHARED, LVParallelState::pcxt, pfree(), pg_atomic_init_u32(), prepare_index_statistics(), RelationData::rd_indam, LVShared::relid, shm_toc_allocate(), shm_toc_estimate_chunk, shm_toc_estimate_keys, shm_toc_insert(), SizeOfDeadTuples, SizeOfLVShared, ParallelContext::toc, VACUUM_OPTION_MAX_VALID_VALUE, VACUUM_OPTION_PARALLEL_BULKDEL, VACUUM_OPTION_PARALLEL_CLEANUP, and VACUUM_OPTION_PARALLEL_COND_CLEANUP.

Referenced by lazy_scan_heap().

{
    LVParallelState *lps = NULL;
    ParallelContext *pcxt;
    LVShared   *shared;
    LVDeadTuples *dead_tuples;
    bool       *can_parallel_vacuum;
    long        maxtuples;
    char       *sharedquery;
    Size        est_shared;
    Size        est_deadtuples;
    int         nindexes_mwm = 0;
    int         parallel_workers = 0;
    int         querylen;
    int         i;

    /*
     * A parallel vacuum must be requested and there must be indexes on the
     * relation
     */
    Assert(nrequested >= 0);
    Assert(nindexes > 0);

    /*
     * Compute the number of parallel vacuum workers to launch
     */
    can_parallel_vacuum = (bool *) palloc0(sizeof(bool) * nindexes);
    parallel_workers = compute_parallel_vacuum_workers(Irel, nindexes,
                                                       nrequested,
                                                       can_parallel_vacuum);

    /* Can't perform vacuum in parallel */
    if (parallel_workers <= 0)
    {
        pfree(can_parallel_vacuum);
        return lps;
    }

    lps = (LVParallelState *) palloc0(sizeof(LVParallelState));

    EnterParallelMode();
    pcxt = CreateParallelContext("postgres", "parallel_vacuum_main",
                                 parallel_workers);
    Assert(pcxt->nworkers > 0);
    lps->pcxt = pcxt;

    /* Estimate size for shared information -- PARALLEL_VACUUM_KEY_SHARED */
    est_shared = MAXALIGN(add_size(SizeOfLVShared, BITMAPLEN(nindexes)));
    for (i = 0; i < nindexes; i++)
    {
        uint8       vacoptions = Irel[i]->rd_indam->amparallelvacuumoptions;

        /*
         * Cleanup option should be either disabled, always performing in
         * parallel or conditionally performing in parallel.
         */
        Assert(((vacoptions & VACUUM_OPTION_PARALLEL_CLEANUP) == 0) ||
               ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) == 0));
        Assert(vacoptions <= VACUUM_OPTION_MAX_VALID_VALUE);

        /* Skip indexes that don't participate in parallel vacuum */
        if (!can_parallel_vacuum[i])
            continue;

        if (Irel[i]->rd_indam->amusemaintenanceworkmem)
            nindexes_mwm++;

        est_shared = add_size(est_shared, sizeof(LVSharedIndStats));

        /*
         * Remember the number of indexes that support parallel operation for
         * each phase.
         */
        if ((vacoptions & VACUUM_OPTION_PARALLEL_BULKDEL) != 0)
            lps->nindexes_parallel_bulkdel++;
        if ((vacoptions & VACUUM_OPTION_PARALLEL_CLEANUP) != 0)
            lps->nindexes_parallel_cleanup++;
        if ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) != 0)
            lps->nindexes_parallel_condcleanup++;
    }
    shm_toc_estimate_chunk(&pcxt->estimator, est_shared);
    shm_toc_estimate_keys(&pcxt->estimator, 1);

    /* Estimate size for dead tuples -- PARALLEL_VACUUM_KEY_DEAD_TUPLES */
    maxtuples = compute_max_dead_tuples(nblocks, true);
    est_deadtuples = MAXALIGN(SizeOfDeadTuples(maxtuples));
    shm_toc_estimate_chunk(&pcxt->estimator, est_deadtuples);
    shm_toc_estimate_keys(&pcxt->estimator, 1);

    /* Finally, estimate PARALLEL_VACUUM_KEY_QUERY_TEXT space */
    querylen = strlen(debug_query_string);
    shm_toc_estimate_chunk(&pcxt->estimator, querylen + 1);
    shm_toc_estimate_keys(&pcxt->estimator, 1);

    InitializeParallelDSM(pcxt);

    /* Prepare shared information */
    shared = (LVShared *) shm_toc_allocate(pcxt->toc, est_shared);
    MemSet(shared, 0, est_shared);
    shared->relid = relid;
    shared->elevel = elevel;
    shared->maintenance_work_mem_worker =
        (nindexes_mwm > 0) ?
        maintenance_work_mem / Min(parallel_workers, nindexes_mwm) :
        maintenance_work_mem;

    pg_atomic_init_u32(&(shared->cost_balance), 0);
    pg_atomic_init_u32(&(shared->active_nworkers), 0);
    pg_atomic_init_u32(&(shared->idx), 0);
    shared->offset = MAXALIGN(add_size(SizeOfLVShared, BITMAPLEN(nindexes)));
    prepare_index_statistics(shared, can_parallel_vacuum, nindexes);

    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_SHARED, shared);
    lps->lvshared = shared;

    /* Prepare the dead tuple space */
    dead_tuples = (LVDeadTuples *) shm_toc_allocate(pcxt->toc, est_deadtuples);
    dead_tuples->max_tuples = maxtuples;
    dead_tuples->num_tuples = 0;
    MemSet(dead_tuples->itemptrs, 0, sizeof(ItemPointerData) * maxtuples);
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_DEAD_TUPLES, dead_tuples);
    vacrelstats->dead_tuples = dead_tuples;

    /* Store query string for workers */
    sharedquery = (char *) shm_toc_allocate(pcxt->toc, querylen + 1);
    memcpy(sharedquery, debug_query_string, querylen + 1);
    sharedquery[querylen] = '\0';
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_QUERY_TEXT, sharedquery);

    pfree(can_parallel_vacuum);
    return lps;
}

compute_max_dead_tuples()

static long compute_max_dead_tuples ( BlockNumber  relblocks, bool  hasindex  )

static

Definition at line 2706 of file vacuumlazy.c.

References autovacuum_work_mem, IsAutoVacuumWorkerProcess(), LAZY_ALLOC_TUPLES, maintenance_work_mem, Max, MaxAllocSize, MAXDEADTUPLES, MaxHeapTuplesPerPage, and Min.

Referenced by begin_parallel_vacuum(), and lazy_space_alloc().

{
    long        maxtuples;
    int         vac_work_mem = IsAutoVacuumWorkerProcess() &&
    autovacuum_work_mem != -1 ?
    autovacuum_work_mem : maintenance_work_mem;

    if (useindex)
    {
        maxtuples = MAXDEADTUPLES(vac_work_mem * 1024L);
        maxtuples = Min(maxtuples, INT_MAX);
        maxtuples = Min(maxtuples, MAXDEADTUPLES(MaxAllocSize));

        /* curious coding here to ensure the multiplication can't overflow */
        if ((BlockNumber) (maxtuples / LAZY_ALLOC_TUPLES) > relblocks)
            maxtuples = relblocks * LAZY_ALLOC_TUPLES;

        /* stay sane if small maintenance_work_mem */
        maxtuples = Max(maxtuples, MaxHeapTuplesPerPage);
    }
    else
        maxtuples = MaxHeapTuplesPerPage;

    return maxtuples;
}

compute_parallel_vacuum_workers()

static int compute_parallel_vacuum_workers ( Relation *  Irel, int  nindexes, int  nrequested, bool *  can_parallel_vacuum  )

static

Definition at line 2950 of file vacuumlazy.c.

References IndexAmRoutine::amparallelvacuumoptions, i, IsUnderPostmaster, Max, max_parallel_maintenance_workers, Min, min_parallel_index_scan_size, RelationData::rd_indam, RelationGetNumberOfBlocks, VACUUM_OPTION_NO_PARALLEL, VACUUM_OPTION_PARALLEL_BULKDEL, VACUUM_OPTION_PARALLEL_CLEANUP, and VACUUM_OPTION_PARALLEL_COND_CLEANUP.

Referenced by begin_parallel_vacuum().

{
    int         nindexes_parallel = 0;
    int         nindexes_parallel_bulkdel = 0;
    int         nindexes_parallel_cleanup = 0;
    int         parallel_workers;
    int         i;

    /*
     * We don't allow to perform parallel operation in standalone backend or
     * when parallelism is disabled.
     */
    if (!IsUnderPostmaster || max_parallel_maintenance_workers == 0)
        return 0;

    /*
     * Compute the number of indexes that can participate in parallel vacuum.
     */
    for (i = 0; i < nindexes; i++)
    {
        uint8       vacoptions = Irel[i]->rd_indam->amparallelvacuumoptions;

        if (vacoptions == VACUUM_OPTION_NO_PARALLEL ||
            RelationGetNumberOfBlocks(Irel[i]) < min_parallel_index_scan_size)
            continue;

        can_parallel_vacuum[i] = true;

        if ((vacoptions & VACUUM_OPTION_PARALLEL_BULKDEL) != 0)
            nindexes_parallel_bulkdel++;
        if (((vacoptions & VACUUM_OPTION_PARALLEL_CLEANUP) != 0) ||
            ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) != 0))
            nindexes_parallel_cleanup++;
    }

    nindexes_parallel = Max(nindexes_parallel_bulkdel,
                            nindexes_parallel_cleanup);

    /* The leader process takes one index */
    nindexes_parallel--;

    /* No index supports parallel vacuum */
    if (nindexes_parallel <= 0)
        return 0;

    /* Compute the parallel degree */
    parallel_workers = (nrequested > 0) ?
        Min(nrequested, nindexes_parallel) : nindexes_parallel;

    /* Cap by max_parallel_maintenance_workers */
    parallel_workers = Min(parallel_workers, max_parallel_maintenance_workers);

    return parallel_workers;
}

count_nondeletable_pages()

static BlockNumber count_nondeletable_pages ( Relation  onerel, LVRelStats *  vacrelstats  )

static

Definition at line 2567 of file vacuumlazy.c.

References AccessExclusiveLock, buf, BUFFER_LOCK_SHARE, BufferGetPage, CHECK_FOR_INTERRUPTS, elevel, ereport, errmsg(), FirstOffsetNumber, INSTR_TIME_GET_MICROSEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, InvalidBlockNumber, ItemIdIsUsed, LVRelStats::lock_waiter_detected, LockBuffer(), LockHasWaitersRelation(), MAIN_FORKNUM, LVRelStats::nonempty_pages, OffsetNumberNext, PageGetItemId, PageGetMaxOffsetNumber, PageIsEmpty, PageIsNew, PREFETCH_SIZE, PrefetchBuffer(), RBM_NORMAL, ReadBufferExtended(), LVRelStats::rel_pages, RelationGetRelationName, StaticAssertStmt, UnlockReleaseBuffer(), and VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL.

Referenced by lazy_truncate_heap().

{
    BlockNumber blkno;
    BlockNumber prefetchedUntil;
    instr_time  starttime;

    /* Initialize the starttime if we check for conflicting lock requests */
    INSTR_TIME_SET_CURRENT(starttime);

    /*
     * Start checking blocks at what we believe relation end to be and move
     * backwards.  (Strange coding of loop control is needed because blkno is
     * unsigned.)  To make the scan faster, we prefetch a few blocks at a time
     * in forward direction, so that OS-level readahead can kick in.
     */
    blkno = vacrelstats->rel_pages;
    StaticAssertStmt((PREFETCH_SIZE & (PREFETCH_SIZE - 1)) == 0,
                     "prefetch size must be power of 2");
    prefetchedUntil = InvalidBlockNumber;
    while (blkno > vacrelstats->nonempty_pages)
    {
        Buffer      buf;
        Page        page;
        OffsetNumber offnum,
                    maxoff;
        bool        hastup;

        /*
         * Check if another process requests a lock on our relation. We are
         * holding an AccessExclusiveLock here, so they will be waiting. We
         * only do this once per VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and we
         * only check if that interval has elapsed once every 32 blocks to
         * keep the number of system calls and actual shared lock table
         * lookups to a minimum.
         */
        if ((blkno % 32) == 0)
        {
            instr_time  currenttime;
            instr_time  elapsed;

            INSTR_TIME_SET_CURRENT(currenttime);
            elapsed = currenttime;
            INSTR_TIME_SUBTRACT(elapsed, starttime);
            if ((INSTR_TIME_GET_MICROSEC(elapsed) / 1000)
                >= VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL)
            {
                if (LockHasWaitersRelation(onerel, AccessExclusiveLock))
                {
                    ereport(elevel,
                            (errmsg("\"%s\": suspending truncate due to conflicting lock request",
                                    RelationGetRelationName(onerel))));

                    vacrelstats->lock_waiter_detected = true;
                    return blkno;
                }
                starttime = currenttime;
            }
        }

        /*
         * We don't insert a vacuum delay point here, because we have an
         * exclusive lock on the table which we want to hold for as short a
         * time as possible.  We still need to check for interrupts however.
         */
        CHECK_FOR_INTERRUPTS();

        blkno--;

        /* If we haven't prefetched this lot yet, do so now. */
        if (prefetchedUntil > blkno)
        {
            BlockNumber prefetchStart;
            BlockNumber pblkno;

            prefetchStart = blkno & ~(PREFETCH_SIZE - 1);
            for (pblkno = prefetchStart; pblkno <= blkno; pblkno++)
            {
                PrefetchBuffer(onerel, MAIN_FORKNUM, pblkno);
                CHECK_FOR_INTERRUPTS();
            }
            prefetchedUntil = prefetchStart;
        }

        buf = ReadBufferExtended(onerel, MAIN_FORKNUM, blkno,
                                 RBM_NORMAL, vac_strategy);

        /* In this phase we only need shared access to the buffer */
        LockBuffer(buf, BUFFER_LOCK_SHARE);

        page = BufferGetPage(buf);

        if (PageIsNew(page) || PageIsEmpty(page))
        {
            UnlockReleaseBuffer(buf);
            continue;
        }

        hastup = false;
        maxoff = PageGetMaxOffsetNumber(page);
        for (offnum = FirstOffsetNumber;
             offnum <= maxoff;
             offnum = OffsetNumberNext(offnum))
        {
            ItemId      itemid;

            itemid = PageGetItemId(page, offnum);

            /*
             * Note: any non-unused item should be taken as a reason to keep
             * this page.  We formerly thought that DEAD tuples could be
             * thrown away, but that's not so, because we'd not have cleaned
             * out their index entries.
             */
            if (ItemIdIsUsed(itemid))
            {
                hastup = true;
                break;          /* can stop scanning */
            }
        }                       /* scan along page */

        UnlockReleaseBuffer(buf);

        /* Done scanning if we found a tuple here */
        if (hastup)
            return blkno + 1;
    }

    /*
     * If we fall out of the loop, all the previously-thought-to-be-empty
     * pages still are; we need not bother to look at the last known-nonempty
     * page.
     */
    return vacrelstats->nonempty_pages;
}

end_parallel_vacuum()

static void end_parallel_vacuum ( Relation *  Irel, IndexBulkDeleteResult **  stats, LVParallelState *  lps, int  nindexes  )

static

Definition at line 3211 of file vacuumlazy.c.

References Assert, DestroyParallelContext(), ExitParallelMode(), get_indstats(), i, IsParallelWorker, LVParallelState::lvshared, palloc0(), LVParallelState::pcxt, pfree(), LVSharedIndStats::stats, and LVSharedIndStats::updated.

Referenced by lazy_scan_heap().

{
    int         i;

    Assert(!IsParallelWorker());

    /* Copy the updated statistics */
    for (i = 0; i < nindexes; i++)
    {
        LVSharedIndStats *indstats = get_indstats(lps->lvshared, i);

        /*
         * Skip unused slot.  The statistics of this index are already stored
         * in local memory.
         */
        if (indstats == NULL)
            continue;

        if (indstats->updated)
        {
            stats[i] = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
            memcpy(stats[i], &(indstats->stats), sizeof(IndexBulkDeleteResult));
        }
        else
            stats[i] = NULL;
    }

    DestroyParallelContext(lps->pcxt);
    ExitParallelMode();

    /* Deactivate parallel vacuum */
    pfree(lps);
    lps = NULL;
}

get_indstats()

static LVSharedIndStats * get_indstats ( LVShared *  lvshared, int  n  )

static

Definition at line 3249 of file vacuumlazy.c.

References GetSharedIndStats, i, and IndStatsIsNull.

Referenced by end_parallel_vacuum(), parallel_vacuum_index(), and vacuum_indexes_leader().

{
    int         i;
    char       *p;

    if (IndStatsIsNull(lvshared, n))
        return NULL;

    p = (char *) GetSharedIndStats(lvshared);
    for (i = 0; i < n; i++)
    {
        if (IndStatsIsNull(lvshared, i))
            continue;

        p += sizeof(LVSharedIndStats);
    }

    return (LVSharedIndStats *) p;
}

heap_page_is_all_visible()

static bool heap_page_is_all_visible ( Relation  rel, Buffer  buf, TransactionId *  visibility_cutoff_xid, bool *  all_frozen  )

static

Definition at line 2831 of file vacuumlazy.c.

References Assert, BufferGetBlockNumber(), BufferGetPage, elog, ERROR, FirstOffsetNumber, heap_tuple_needs_eventual_freeze(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetXmin, HeapTupleHeaderXminCommitted, HeapTupleSatisfiesVacuum(), InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet, OffsetNumberNext, OldestXmin, PageGetItem, PageGetItemId, PageGetMaxOffsetNumber, RelationGetRelid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdFollows(), and TransactionIdPrecedes().

Referenced by lazy_vacuum_page().

{
    Page        page = BufferGetPage(buf);
    BlockNumber blockno = BufferGetBlockNumber(buf);
    OffsetNumber offnum,
                maxoff;
    bool        all_visible = true;

    *visibility_cutoff_xid = InvalidTransactionId;
    *all_frozen = true;

    /*
     * This is a stripped down version of the line pointer scan in
     * lazy_scan_heap(). So if you change anything here, also check that code.
     */
    maxoff = PageGetMaxOffsetNumber(page);
    for (offnum = FirstOffsetNumber;
         offnum <= maxoff && all_visible;
         offnum = OffsetNumberNext(offnum))
    {
        ItemId      itemid;
        HeapTupleData tuple;

        itemid = PageGetItemId(page, offnum);

        /* Unused or redirect line pointers are of no interest */
        if (!ItemIdIsUsed(itemid) || ItemIdIsRedirected(itemid))
            continue;

        ItemPointerSet(&(tuple.t_self), blockno, offnum);

        /*
         * Dead line pointers can have index pointers pointing to them. So
         * they can't be treated as visible
         */
        if (ItemIdIsDead(itemid))
        {
            all_visible = false;
            *all_frozen = false;
            break;
        }

        Assert(ItemIdIsNormal(itemid));

        tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
        tuple.t_len = ItemIdGetLength(itemid);
        tuple.t_tableOid = RelationGetRelid(rel);

        switch (HeapTupleSatisfiesVacuum(&tuple, OldestXmin, buf))
        {
            case HEAPTUPLE_LIVE:
                {
                    TransactionId xmin;

                    /* Check comments in lazy_scan_heap. */
                    if (!HeapTupleHeaderXminCommitted(tuple.t_data))
                    {
                        all_visible = false;
                        *all_frozen = false;
                        break;
                    }

                    /*
                     * The inserter definitely committed. But is it old enough
                     * that everyone sees it as committed?
                     */
                    xmin = HeapTupleHeaderGetXmin(tuple.t_data);
                    if (!TransactionIdPrecedes(xmin, OldestXmin))
                    {
                        all_visible = false;
                        *all_frozen = false;
                        break;
                    }

                    /* Track newest xmin on page. */
                    if (TransactionIdFollows(xmin, *visibility_cutoff_xid))
                        *visibility_cutoff_xid = xmin;

                    /* Check whether this tuple is already frozen or not */
                    if (all_visible && *all_frozen &&
                        heap_tuple_needs_eventual_freeze(tuple.t_data))
                        *all_frozen = false;
                }
                break;

            case HEAPTUPLE_DEAD:
            case HEAPTUPLE_RECENTLY_DEAD:
            case HEAPTUPLE_INSERT_IN_PROGRESS:
            case HEAPTUPLE_DELETE_IN_PROGRESS:
                {
                    all_visible = false;
                    *all_frozen = false;
                    break;
                }
            default:
                elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                break;
        }
    }                           /* scan along page */

    return all_visible;
}

heap_vacuum_rel()

void heap_vacuum_rel	(	Relation	onerel,
		VacuumParams *	params,
		BufferAccessStrategy	bstrategy
	)

Definition at line 376 of file vacuumlazy.c.

References _, appendStringInfo(), Assert, buf, StringInfoData::data, DEBUG1, DEBUG2, elevel, ereport, errmsg(), errmsg_internal(), VacuumParams::freeze_min_age, VacuumParams::freeze_table_age, FreezeLimit, LVRelStats::frozenskipped_pages, get_database_name(), get_namespace_name(), GetCurrentTimestamp(), VacuumParams::index_cleanup, INFO, initStringInfo(), InvalidMultiXactId, InvalidTransactionId, VacuumParams::is_wraparound, IsAutoVacuumWorkerProcess(), lazy_scan_heap(), lazy_truncate_heap(), LVRelStats::lock_waiter_detected, LOG, VacuumParams::log_min_duration, VacuumParams::multixact_freeze_min_age, VacuumParams::multixact_freeze_table_age, MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedesOrEquals(), MyDatabaseId, LVRelStats::new_dead_tuples, LVRelStats::new_live_tuples, LVRelStats::new_rel_tuples, NoLock, LVRelStats::num_index_scans, LVRelStats::old_live_tuples, LVRelStats::old_rel_pages, OldestXmin, VacuumParams::options, LVRelStats::pages_removed, palloc0(), pfree(), pg_rusage_init(), pg_rusage_show(), pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), pgstat_report_vacuum(), LVRelStats::pinskipped_pages, PROGRESS_COMMAND_VACUUM, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_FINAL_CLEANUP, RelationData::rd_rel, LVRelStats::rel_pages, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, LVRelStats::scanned_pages, should_attempt_truncation(), TimestampDifference(), TimestampDifferenceExceeds(), TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), VacuumParams::truncate, LVRelStats::tupcount_pages, LVRelStats::tuples_deleted, LVRelStats::useindex, vac_close_indexes(), vac_open_indexes(), vac_update_relstats(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_TERNARY_DEFAULT, VACOPT_TERNARY_ENABLED, VACOPT_VERBOSE, vacuum_set_xid_limits(), VacuumPageDirty, VacuumPageHit, VacuumPageMiss, and visibilitymap_count().

Referenced by SampleHeapTupleVisible().

{
    LVRelStats *vacrelstats;
    Relation   *Irel;
    int         nindexes;
    PGRUsage    ru0;
    TimestampTz starttime = 0;
    long        secs;
    int         usecs;
    double      read_rate,
                write_rate;
    bool        aggressive;     /* should we scan all unfrozen pages? */
    bool        scanned_all_unfrozen;   /* actually scanned all such pages? */
    TransactionId xidFullScanLimit;
    MultiXactId mxactFullScanLimit;
    BlockNumber new_rel_pages;
    BlockNumber new_rel_allvisible;
    double      new_live_tuples;
    TransactionId new_frozen_xid;
    MultiXactId new_min_multi;

    Assert(params != NULL);
    Assert(params->index_cleanup != VACOPT_TERNARY_DEFAULT);
    Assert(params->truncate != VACOPT_TERNARY_DEFAULT);

    /* not every AM requires these to be valid, but heap does */
    Assert(TransactionIdIsNormal(onerel->rd_rel->relfrozenxid));
    Assert(MultiXactIdIsValid(onerel->rd_rel->relminmxid));

    /* measure elapsed time iff autovacuum logging requires it */
    if (IsAutoVacuumWorkerProcess() && params->log_min_duration >= 0)
    {
        pg_rusage_init(&ru0);
        starttime = GetCurrentTimestamp();
    }

    if (params->options & VACOPT_VERBOSE)
        elevel = INFO;
    else
        elevel = DEBUG2;

    pgstat_progress_start_command(PROGRESS_COMMAND_VACUUM,
                                  RelationGetRelid(onerel));

    vac_strategy = bstrategy;

    vacuum_set_xid_limits(onerel,
                          params->freeze_min_age,
                          params->freeze_table_age,
                          params->multixact_freeze_min_age,
                          params->multixact_freeze_table_age,
                          &OldestXmin, &FreezeLimit, &xidFullScanLimit,
                          &MultiXactCutoff, &mxactFullScanLimit);

    /*
     * We request an aggressive scan if the table's frozen Xid is now older
     * than or equal to the requested Xid full-table scan limit; or if the
     * table's minimum MultiXactId is older than or equal to the requested
     * mxid full-table scan limit; or if DISABLE_PAGE_SKIPPING was specified.
     */
    aggressive = TransactionIdPrecedesOrEquals(onerel->rd_rel->relfrozenxid,
                                               xidFullScanLimit);
    aggressive |= MultiXactIdPrecedesOrEquals(onerel->rd_rel->relminmxid,
                                              mxactFullScanLimit);
    if (params->options & VACOPT_DISABLE_PAGE_SKIPPING)
        aggressive = true;

    /*
     * Normally the relfrozenxid for an anti-wraparound vacuum will be old
     * enough to force an aggressive vacuum.  However, a concurrent vacuum
     * might have already done this work that the relfrozenxid in relcache has
     * been updated.  If that happens this vacuum is redundant, so skip it.
     */
    if (params->is_wraparound && !aggressive)
    {
        ereport(DEBUG1,
                (errmsg("skipping redundant vacuum to prevent wraparound of table \"%s.%s.%s\"",
                        get_database_name(MyDatabaseId),
                        get_namespace_name(RelationGetNamespace(onerel)),
                        RelationGetRelationName(onerel))));
        pgstat_progress_end_command();
        return;
    }

    vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));

    vacrelstats->old_rel_pages = onerel->rd_rel->relpages;
    vacrelstats->old_live_tuples = onerel->rd_rel->reltuples;
    vacrelstats->num_index_scans = 0;
    vacrelstats->pages_removed = 0;
    vacrelstats->lock_waiter_detected = false;

    /* Open all indexes of the relation */
    vac_open_indexes(onerel, RowExclusiveLock, &nindexes, &Irel);
    vacrelstats->useindex = (nindexes > 0 &&
                             params->index_cleanup == VACOPT_TERNARY_ENABLED);

    /* Do the vacuuming */
    lazy_scan_heap(onerel, params, vacrelstats, Irel, nindexes, aggressive);

    /* Done with indexes */
    vac_close_indexes(nindexes, Irel, NoLock);

    /*
     * Compute whether we actually scanned the all unfrozen pages. If we did,
     * we can adjust relfrozenxid and relminmxid.
     *
     * NB: We need to check this before truncating the relation, because that
     * will change ->rel_pages.
     */
    if ((vacrelstats->scanned_pages + vacrelstats->frozenskipped_pages)
        < vacrelstats->rel_pages)
    {
        Assert(!aggressive);
        scanned_all_unfrozen = false;
    }
    else
        scanned_all_unfrozen = true;

    /*
     * Optionally truncate the relation.
     */
    if (should_attempt_truncation(params, vacrelstats))
        lazy_truncate_heap(onerel, vacrelstats);

    /* Report that we are now doing final cleanup */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_FINAL_CLEANUP);

    /*
     * Update statistics in pg_class.
     *
     * A corner case here is that if we scanned no pages at all because every
     * page is all-visible, we should not update relpages/reltuples, because
     * we have no new information to contribute.  In particular this keeps us
     * from replacing relpages=reltuples=0 (which means "unknown tuple
     * density") with nonzero relpages and reltuples=0 (which means "zero
     * tuple density") unless there's some actual evidence for the latter.
     *
     * It's important that we use tupcount_pages and not scanned_pages for the
     * check described above; scanned_pages counts pages where we could not
     * get cleanup lock, and which were processed only for frozenxid purposes.
     *
     * We do update relallvisible even in the corner case, since if the table
     * is all-visible we'd definitely like to know that.  But clamp the value
     * to be not more than what we're setting relpages to.
     *
     * Also, don't change relfrozenxid/relminmxid if we skipped any pages,
     * since then we don't know for certain that all tuples have a newer xmin.
     */
    new_rel_pages = vacrelstats->rel_pages;
    new_live_tuples = vacrelstats->new_live_tuples;
    if (vacrelstats->tupcount_pages == 0 && new_rel_pages > 0)
    {
        new_rel_pages = vacrelstats->old_rel_pages;
        new_live_tuples = vacrelstats->old_live_tuples;
    }

    visibilitymap_count(onerel, &new_rel_allvisible, NULL);
    if (new_rel_allvisible > new_rel_pages)
        new_rel_allvisible = new_rel_pages;

    new_frozen_xid = scanned_all_unfrozen ? FreezeLimit : InvalidTransactionId;
    new_min_multi = scanned_all_unfrozen ? MultiXactCutoff : InvalidMultiXactId;

    vac_update_relstats(onerel,
                        new_rel_pages,
                        new_live_tuples,
                        new_rel_allvisible,
                        nindexes > 0,
                        new_frozen_xid,
                        new_min_multi,
                        false);

    /* report results to the stats collector, too */
    pgstat_report_vacuum(RelationGetRelid(onerel),
                         onerel->rd_rel->relisshared,
                         new_live_tuples,
                         vacrelstats->new_dead_tuples);
    pgstat_progress_end_command();

    /* and log the action if appropriate */
    if (IsAutoVacuumWorkerProcess() && params->log_min_duration >= 0)
    {
        TimestampTz endtime = GetCurrentTimestamp();

        if (params->log_min_duration == 0 ||
            TimestampDifferenceExceeds(starttime, endtime,
                                       params->log_min_duration))
        {
            StringInfoData buf;
            char       *msgfmt;

            TimestampDifference(starttime, endtime, &secs, &usecs);

            read_rate = 0;
            write_rate = 0;
            if ((secs > 0) || (usecs > 0))
            {
                read_rate = (double) BLCKSZ * VacuumPageMiss / (1024 * 1024) /
                    (secs + usecs / 1000000.0);
                write_rate = (double) BLCKSZ * VacuumPageDirty / (1024 * 1024) /
                    (secs + usecs / 1000000.0);
            }

            /*
             * This is pretty messy, but we split it up so that we can skip
             * emitting individual parts of the message when not applicable.
             */
            initStringInfo(&buf);
            if (params->is_wraparound)
            {
                /* an anti-wraparound vacuum has to be aggressive */
                Assert(aggressive);
                msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
            }
            else
            {
                if (aggressive)
                    msgfmt = _("automatic aggressive vacuum of table \"%s.%s.%s\": index scans: %d\n");
                else
                    msgfmt = _("automatic vacuum of table \"%s.%s.%s\": index scans: %d\n");
            }
            appendStringInfo(&buf, msgfmt,
                             get_database_name(MyDatabaseId),
                             get_namespace_name(RelationGetNamespace(onerel)),
                             RelationGetRelationName(onerel),
                             vacrelstats->num_index_scans);
            appendStringInfo(&buf, _("pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n"),
                             vacrelstats->pages_removed,
                             vacrelstats->rel_pages,
                             vacrelstats->pinskipped_pages,
                             vacrelstats->frozenskipped_pages);
            appendStringInfo(&buf,
                             _("tuples: %.0f removed, %.0f remain, %.0f are dead but not yet removable, oldest xmin: %u\n"),
                             vacrelstats->tuples_deleted,
                             vacrelstats->new_rel_tuples,
                             vacrelstats->new_dead_tuples,
                             OldestXmin);
            appendStringInfo(&buf,
                             _("buffer usage: %lld hits, %lld misses, %lld dirtied\n"),
                             (long long) VacuumPageHit,
                             (long long) VacuumPageMiss,
                             (long long) VacuumPageDirty);
            appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
                             read_rate, write_rate);
            appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));

            ereport(LOG,
                    (errmsg_internal("%s", buf.data)));
            pfree(buf.data);
        }
    }
}

lazy_check_needs_freeze()

static bool lazy_check_needs_freeze ( Buffer  buf, bool *  hastup  )

static

Definition at line 1937 of file vacuumlazy.c.

References BufferGetPage, FirstOffsetNumber, FreezeLimit, heap_tuple_needs_freeze(), ItemIdIsNormal, ItemIdIsUsed, MultiXactCutoff, OffsetNumberNext, PageGetItem, PageGetItemId, PageGetMaxOffsetNumber, PageIsEmpty, and PageIsNew.

Referenced by lazy_scan_heap().

{
    Page        page = BufferGetPage(buf);
    OffsetNumber offnum,
                maxoff;
    HeapTupleHeader tupleheader;

    *hastup = false;

    /*
     * New and empty pages, obviously, don't contain tuples. We could make
     * sure that the page is registered in the FSM, but it doesn't seem worth
     * waiting for a cleanup lock just for that, especially because it's
     * likely that the pin holder will do so.
     */
    if (PageIsNew(page) || PageIsEmpty(page))
        return false;

    maxoff = PageGetMaxOffsetNumber(page);
    for (offnum = FirstOffsetNumber;
         offnum <= maxoff;
         offnum = OffsetNumberNext(offnum))
    {
        ItemId      itemid;

        itemid = PageGetItemId(page, offnum);

        /* this should match hastup test in count_nondeletable_pages() */
        if (ItemIdIsUsed(itemid))
            *hastup = true;

        /* dead and redirect items never need freezing */
        if (!ItemIdIsNormal(itemid))
            continue;

        tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);

        if (heap_tuple_needs_freeze(tupleheader, FreezeLimit,
                                    MultiXactCutoff, buf))
            return true;
    }                           /* scan along page */

    return false;
}

lazy_cleanup_all_indexes()

static void lazy_cleanup_all_indexes ( Relation *  Irel, IndexBulkDeleteResult **  stats, LVRelStats *  vacrelstats, LVParallelState *  lps, int  nindexes  )

static

Definition at line 2261 of file vacuumlazy.c.

References Assert, LVShared::estimated_count, LVShared::first_time, LVShared::for_cleanup, idx(), IsParallelWorker, lazy_cleanup_index(), lazy_parallel_vacuum_indexes(), LVParallelState::lvshared, LVRelStats::new_rel_tuples, LVRelStats::num_index_scans, ParallelVacuumIsActive, pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_INDEX_CLEANUP, LVRelStats::rel_pages, LVShared::reltuples, and LVRelStats::tupcount_pages.

Referenced by lazy_scan_heap().

{
    int         idx;

    Assert(!IsParallelWorker());
    Assert(nindexes > 0);

    /* Report that we are now cleaning up indexes */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_INDEX_CLEANUP);

    /*
     * If parallel vacuum is active we perform index cleanup with parallel
     * workers.
     */
    if (ParallelVacuumIsActive(lps))
    {
        /* Tell parallel workers to do index cleanup */
        lps->lvshared->for_cleanup = true;
        lps->lvshared->first_time =
            (vacrelstats->num_index_scans == 0);

        /*
         * Now we can provide a better estimate of total number of surviving
         * tuples (we assume indexes are more interested in that than in the
         * number of nominally live tuples).
         */
        lps->lvshared->reltuples = vacrelstats->new_rel_tuples;
        lps->lvshared->estimated_count =
            (vacrelstats->tupcount_pages < vacrelstats->rel_pages);

        lazy_parallel_vacuum_indexes(Irel, stats, vacrelstats, lps, nindexes);
    }
    else
    {
        for (idx = 0; idx < nindexes; idx++)
            lazy_cleanup_index(Irel[idx], &stats[idx],
                               vacrelstats->new_rel_tuples,
                               vacrelstats->tupcount_pages < vacrelstats->rel_pages);
    }
}

lazy_cleanup_index()

static void lazy_cleanup_index ( Relation  indrel, IndexBulkDeleteResult **  stats, double  reltuples, bool  estimated_count  )

static

Definition at line 2355 of file vacuumlazy.c.

References IndexVacuumInfo::analyze_only, elevel, ereport, errdetail(), errmsg(), IndexVacuumInfo::estimated_count, gettext_noop, IndexVacuumInfo::index, index_vacuum_cleanup(), IsParallelWorker, IndexVacuumInfo::message_level, IndexVacuumInfo::num_heap_tuples, pg_rusage_init(), pg_rusage_show(), RelationGetRelationName, IndexVacuumInfo::report_progress, IndexVacuumInfo::strategy, and vac_strategy.

Referenced by lazy_cleanup_all_indexes(), and vacuum_one_index().

{
    IndexVacuumInfo ivinfo;
    const char *msg;
    PGRUsage    ru0;

    pg_rusage_init(&ru0);

    ivinfo.index = indrel;
    ivinfo.analyze_only = false;
    ivinfo.report_progress = false;
    ivinfo.estimated_count = estimated_count;
    ivinfo.message_level = elevel;

    ivinfo.num_heap_tuples = reltuples;
    ivinfo.strategy = vac_strategy;

    *stats = index_vacuum_cleanup(&ivinfo, *stats);

    if (!(*stats))
        return;

    if (IsParallelWorker())
        msg = gettext_noop("index \"%s\" now contains %.0f row versions in %u pages as reported by parallel vacuum worker");
    else
        msg = gettext_noop("index \"%s\" now contains %.0f row versions in %u pages");

    ereport(elevel,
            (errmsg(msg,
                    RelationGetRelationName(indrel),
                    (*stats)->num_index_tuples,
                    (*stats)->num_pages),
             errdetail("%.0f index row versions were removed.\n"
                       "%u index pages have been deleted, %u are currently reusable.\n"
                       "%s.",
                       (*stats)->tuples_removed,
                       (*stats)->pages_deleted, (*stats)->pages_free,
                       pg_rusage_show(&ru0))));
}

lazy_parallel_vacuum_indexes()

static void lazy_parallel_vacuum_indexes ( Relation *  Irel, IndexBulkDeleteResult **  stats, LVRelStats *  vacrelstats, LVParallelState *  lps, int  nindexes  )

static

Definition at line 1989 of file vacuumlazy.c.

References LVShared::active_nworkers, Assert, LVShared::cost_balance, LVRelStats::dead_tuples, elevel, ereport, errmsg(), LVShared::first_time, LVShared::for_cleanup, LVShared::idx, IsParallelWorker, LaunchParallelWorkers(), LVParallelState::lvshared, Min, ngettext, LVParallelState::nindexes_parallel_bulkdel, LVParallelState::nindexes_parallel_cleanup, LVParallelState::nindexes_parallel_condcleanup, LVRelStats::num_index_scans, ParallelContext::nworkers, ParallelContext::nworkers_launched, parallel_vacuum_index(), ParallelVacuumIsActive, LVParallelState::pcxt, pg_atomic_read_u32(), pg_atomic_write_u32(), ReinitializeParallelDSM(), ReinitializeParallelWorkers(), vacuum_indexes_leader(), VacuumActiveNWorkers, VacuumCostBalance, VacuumCostBalanceLocal, VacuumSharedCostBalance, and WaitForParallelWorkersToFinish().

Referenced by lazy_cleanup_all_indexes(), and lazy_vacuum_all_indexes().

{
    int         nworkers;

    Assert(!IsParallelWorker());
    Assert(ParallelVacuumIsActive(lps));
    Assert(nindexes > 0);

    /* Determine the number of parallel workers to launch */
    if (lps->lvshared->for_cleanup)
    {
        if (lps->lvshared->first_time)
            nworkers = lps->nindexes_parallel_cleanup +
                lps->nindexes_parallel_condcleanup;
        else
            nworkers = lps->nindexes_parallel_cleanup;
    }
    else
        nworkers = lps->nindexes_parallel_bulkdel;

    /* The leader process will participate */
    nworkers--;

    /*
     * It is possible that parallel context is initialized with fewer workers
     * than the number of indexes that need a separate worker in the current
     * phase, so we need to consider it.  See compute_parallel_vacuum_workers.
     */
    nworkers = Min(nworkers, lps->pcxt->nworkers);

    /* Setup the shared cost-based vacuum delay and launch workers */
    if (nworkers > 0)
    {
        if (vacrelstats->num_index_scans > 0)
        {
            /* Reset the parallel index processing counter */
            pg_atomic_write_u32(&(lps->lvshared->idx), 0);

            /* Reinitialize the parallel context to relaunch parallel workers */
            ReinitializeParallelDSM(lps->pcxt);
        }

        /*
         * Set up shared cost balance and the number of active workers for
         * vacuum delay.  We need to do this before launching workers as
         * otherwise, they might not see the updated values for these
         * parameters.
         */
        pg_atomic_write_u32(&(lps->lvshared->cost_balance), VacuumCostBalance);
        pg_atomic_write_u32(&(lps->lvshared->active_nworkers), 0);

        /*
         * The number of workers can vary between bulkdelete and cleanup
         * phase.
         */
        ReinitializeParallelWorkers(lps->pcxt, nworkers);

        LaunchParallelWorkers(lps->pcxt);

        if (lps->pcxt->nworkers_launched > 0)
        {
            /*
             * Reset the local cost values for leader backend as we have
             * already accumulated the remaining balance of heap.
             */
            VacuumCostBalance = 0;
            VacuumCostBalanceLocal = 0;

            /* Enable shared cost balance for leader backend */
            VacuumSharedCostBalance = &(lps->lvshared->cost_balance);
            VacuumActiveNWorkers = &(lps->lvshared->active_nworkers);
        }

        if (lps->lvshared->for_cleanup)
            ereport(elevel,
                    (errmsg(ngettext("launched %d parallel vacuum worker for index cleanup (planned: %d)",
                                     "launched %d parallel vacuum workers for index cleanup (planned: %d)",
                                     lps->pcxt->nworkers_launched),
                            lps->pcxt->nworkers_launched, nworkers)));
        else
            ereport(elevel,
                    (errmsg(ngettext("launched %d parallel vacuum worker for index vacuuming (planned: %d)",
                                     "launched %d parallel vacuum workers for index vacuuming (planned: %d)",
                                     lps->pcxt->nworkers_launched),
                            lps->pcxt->nworkers_launched, nworkers)));
    }

    /* Process the indexes that can be processed by only leader process */
    vacuum_indexes_leader(Irel, stats, vacrelstats, lps, nindexes);

    /*
     * Join as a parallel worker.  The leader process alone processes all the
     * indexes in the case where no workers are launched.
     */
    parallel_vacuum_index(Irel, stats, lps->lvshared,
                          vacrelstats->dead_tuples, nindexes);

    /* Wait for all vacuum workers to finish */
    WaitForParallelWorkersToFinish(lps->pcxt);

    /*
     * Carry the shared balance value to heap scan and disable shared costing
     */
    if (VacuumSharedCostBalance)
    {
        VacuumCostBalance = pg_atomic_read_u32(VacuumSharedCostBalance);
        VacuumSharedCostBalance = NULL;
        VacuumActiveNWorkers = NULL;
    }
}

lazy_record_dead_tuple()

static void lazy_record_dead_tuple ( LVDeadTuples *  dead_tuples, ItemPointer  itemptr  )

static

Definition at line 2756 of file vacuumlazy.c.

References LVDeadTuples::itemptrs, LVDeadTuples::max_tuples, LVDeadTuples::num_tuples, pgstat_progress_update_param(), and PROGRESS_VACUUM_NUM_DEAD_TUPLES.

Referenced by lazy_scan_heap().

{
    /*
     * The array shouldn't overflow under normal behavior, but perhaps it
     * could if we are given a really small maintenance_work_mem. In that
     * case, just forget the last few tuples (we'll get 'em next time).
     */
    if (dead_tuples->num_tuples < dead_tuples->max_tuples)
    {
        dead_tuples->itemptrs[dead_tuples->num_tuples] = *itemptr;
        dead_tuples->num_tuples++;
        pgstat_progress_update_param(PROGRESS_VACUUM_NUM_DEAD_TUPLES,
                                     dead_tuples->num_tuples);
    }
}

lazy_scan_heap()

static void lazy_scan_heap ( Relation  onerel, VacuumParams *  params, LVRelStats *  vacrelstats, Relation *  Irel, int  nindexes, bool  aggressive  )

static

Definition at line 694 of file vacuumlazy.c.

References _, appendStringInfo(), Assert, begin_parallel_vacuum(), buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage, BufferGetPageSize, BufferIsValid, ConditionalLockBufferForCleanup(), StringInfoData::data, LVRelStats::dead_tuples, elevel, elog, END_CRIT_SECTION, end_parallel_vacuum(), ereport, errdetail_internal(), errmsg(), ERROR, FirstOffsetNumber, FORCE_CHECK_PAGE, FreeSpaceMapVacuumRange(), FreezeLimit, LVRelStats::frozenskipped_pages, get_namespace_name(), GetRecordedFreeSpace(), heap_execute_freeze_tuple(), heap_page_prune(), heap_prepare_freeze_tuple(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderAdvanceLatestRemovedXid(), HeapTupleHeaderGetXmin, HeapTupleHeaderXminCommitted, HeapTupleIsHeapOnly, HeapTupleIsHotUpdated, HeapTupleSatisfiesVacuum(), i, VacuumParams::index_cleanup, initStringInfo(), InvalidBuffer, InvalidTransactionId, InvalidXLogRecPtr, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet, LVRelStats::latestRemovedXid, lazy_check_needs_freeze(), lazy_cleanup_all_indexes(), lazy_record_dead_tuple(), lazy_space_alloc(), lazy_vacuum_all_indexes(), lazy_vacuum_heap(), lazy_vacuum_page(), LockBuffer(), LockBufferForCleanup(), log_heap_freeze(), log_newpage_buffer(), MAIN_FORKNUM, MarkBufferDirty(), LVDeadTuples::max_tuples, MaxHeapTuplesPerPage, MultiXactCutoff, LVRelStats::new_dead_tuples, LVRelStats::new_live_tuples, LVRelStats::new_rel_tuples, ngettext, LVRelStats::nonempty_pages, LVDeadTuples::num_tuples, VacuumParams::nworkers, xl_heap_freeze_tuple::offset, OffsetNumberNext, OldestXmin, VacuumParams::options, PageClearAllVisible, PageGetHeapFreeSpace(), PageGetItem, PageGetItemId, PageGetLSN, PageGetMaxOffsetNumber, PageIsAllVisible, PageIsEmpty, PageIsNew, PageSetAllVisible, PageSetLSN, palloc(), palloc0(), ParallelVacuumIsActive, pfree(), pg_rusage_init(), pg_rusage_show(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), LVRelStats::pinskipped_pages, PROGRESS_VACUUM_HEAP_BLKS_SCANNED, PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, PROGRESS_VACUUM_MAX_DEAD_TUPLES, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_SCAN_HEAP, PROGRESS_VACUUM_TOTAL_HEAP_BLKS, RBM_NORMAL, RelationData::rd_rel, ReadBufferExtended(), RecordPageWithFreeSpace(), LVRelStats::rel_pages, RelationGetNamespace, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, RelationNeedsWAL, RelationUsesLocalBuffers, ReleaseBuffer(), relname, LVRelStats::scanned_pages, SizeOfPageHeaderData, SKIP_PAGES_THRESHOLD, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdFollows(), TransactionIdPrecedes(), LVRelStats::tupcount_pages, LVRelStats::tuples_deleted, UnlockReleaseBuffer(), update_index_statistics(), LVRelStats::useindex, vac_estimate_reltuples(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_TERNARY_DISABLED, vacuum_delay_point(), VACUUM_FSM_EVERY_PAGES, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_clear(), visibilitymap_get_status(), visibilitymap_pin(), visibilitymap_set(), VISIBILITYMAP_VALID_BITS, VM_ALL_FROZEN, VM_ALL_VISIBLE, and WARNING.

Referenced by heap_vacuum_rel().

{
    LVParallelState *lps = NULL;
    LVDeadTuples *dead_tuples;
    BlockNumber nblocks,
                blkno;
    HeapTupleData tuple;
    char       *relname;
    TransactionId relfrozenxid = onerel->rd_rel->relfrozenxid;
    TransactionId relminmxid = onerel->rd_rel->relminmxid;
    BlockNumber empty_pages,
                vacuumed_pages,
                next_fsm_block_to_vacuum;
    double      num_tuples,     /* total number of nonremovable tuples */
                live_tuples,    /* live tuples (reltuples estimate) */
                tups_vacuumed,  /* tuples cleaned up by vacuum */
                nkeep,          /* dead-but-not-removable tuples */
                nunused;        /* unused line pointers */
    IndexBulkDeleteResult **indstats;
    int         i;
    PGRUsage    ru0;
    Buffer      vmbuffer = InvalidBuffer;
    BlockNumber next_unskippable_block;
    bool        skipping_blocks;
    xl_heap_freeze_tuple *frozen;
    StringInfoData buf;
    const int   initprog_index[] = {
        PROGRESS_VACUUM_PHASE,
        PROGRESS_VACUUM_TOTAL_HEAP_BLKS,
        PROGRESS_VACUUM_MAX_DEAD_TUPLES
    };
    int64       initprog_val[3];

    pg_rusage_init(&ru0);

    relname = RelationGetRelationName(onerel);
    if (aggressive)
        ereport(elevel,
                (errmsg("aggressively vacuuming \"%s.%s\"",
                        get_namespace_name(RelationGetNamespace(onerel)),
                        relname)));
    else
        ereport(elevel,
                (errmsg("vacuuming \"%s.%s\"",
                        get_namespace_name(RelationGetNamespace(onerel)),
                        relname)));

    empty_pages = vacuumed_pages = 0;
    next_fsm_block_to_vacuum = (BlockNumber) 0;
    num_tuples = live_tuples = tups_vacuumed = nkeep = nunused = 0;

    indstats = (IndexBulkDeleteResult **)
        palloc0(nindexes * sizeof(IndexBulkDeleteResult *));

    nblocks = RelationGetNumberOfBlocks(onerel);
    vacrelstats->rel_pages = nblocks;
    vacrelstats->scanned_pages = 0;
    vacrelstats->tupcount_pages = 0;
    vacrelstats->nonempty_pages = 0;
    vacrelstats->latestRemovedXid = InvalidTransactionId;

    /*
     * Initialize the state for a parallel vacuum.  As of now, only one worker
     * can be used for an index, so we invoke parallelism only if there are at
     * least two indexes on a table.
     */
    if (params->nworkers >= 0 && vacrelstats->useindex && nindexes > 1)
    {
        /*
         * Since parallel workers cannot access data in temporary tables, we
         * can't perform parallel vacuum on them.
         */
        if (RelationUsesLocalBuffers(onerel))
        {
            /*
             * Give warning only if the user explicitly tries to perform a
             * parallel vacuum on the temporary table.
             */
            if (params->nworkers > 0)
                ereport(WARNING,
                        (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
                                RelationGetRelationName(onerel))));
        }
        else
            lps = begin_parallel_vacuum(RelationGetRelid(onerel), Irel,
                                        vacrelstats, nblocks, nindexes,
                                        params->nworkers);
    }

    /*
     * Allocate the space for dead tuples in case the parallel vacuum is not
     * initialized.
     */
    if (!ParallelVacuumIsActive(lps))
        lazy_space_alloc(vacrelstats, nblocks);

    dead_tuples = vacrelstats->dead_tuples;
    frozen = palloc(sizeof(xl_heap_freeze_tuple) * MaxHeapTuplesPerPage);

    /* Report that we're scanning the heap, advertising total # of blocks */
    initprog_val[0] = PROGRESS_VACUUM_PHASE_SCAN_HEAP;
    initprog_val[1] = nblocks;
    initprog_val[2] = dead_tuples->max_tuples;
    pgstat_progress_update_multi_param(3, initprog_index, initprog_val);

    /*
     * Except when aggressive is set, we want to skip pages that are
     * all-visible according to the visibility map, but only when we can skip
     * at least SKIP_PAGES_THRESHOLD consecutive pages.  Since we're reading
     * sequentially, the OS should be doing readahead for us, so there's no
     * gain in skipping a page now and then; that's likely to disable
     * readahead and so be counterproductive. Also, skipping even a single
     * page means that we can't update relfrozenxid, so we only want to do it
     * if we can skip a goodly number of pages.
     *
     * When aggressive is set, we can't skip pages just because they are
     * all-visible, but we can still skip pages that are all-frozen, since
     * such pages do not need freezing and do not affect the value that we can
     * safely set for relfrozenxid or relminmxid.
     *
     * Before entering the main loop, establish the invariant that
     * next_unskippable_block is the next block number >= blkno that we can't
     * skip based on the visibility map, either all-visible for a regular scan
     * or all-frozen for an aggressive scan.  We set it to nblocks if there's
     * no such block.  We also set up the skipping_blocks flag correctly at
     * this stage.
     *
     * Note: The value returned by visibilitymap_get_status could be slightly
     * out-of-date, since we make this test before reading the corresponding
     * heap page or locking the buffer.  This is OK.  If we mistakenly think
     * that the page is all-visible or all-frozen when in fact the flag's just
     * been cleared, we might fail to vacuum the page.  It's easy to see that
     * skipping a page when aggressive is not set is not a very big deal; we
     * might leave some dead tuples lying around, but the next vacuum will
     * find them.  But even when aggressive *is* set, it's still OK if we miss
     * a page whose all-frozen marking has just been cleared.  Any new XIDs
     * just added to that page are necessarily newer than the GlobalXmin we
     * computed, so they'll have no effect on the value to which we can safely
     * set relfrozenxid.  A similar argument applies for MXIDs and relminmxid.
     *
     * We will scan the table's last page, at least to the extent of
     * determining whether it has tuples or not, even if it should be skipped
     * according to the above rules; except when we've already determined that
     * it's not worth trying to truncate the table.  This avoids having
     * lazy_truncate_heap() take access-exclusive lock on the table to attempt
     * a truncation that just fails immediately because there are tuples in
     * the last page.  This is worth avoiding mainly because such a lock must
     * be replayed on any hot standby, where it can be disruptive.
     */
    next_unskippable_block = 0;
    if ((params->options & VACOPT_DISABLE_PAGE_SKIPPING) == 0)
    {
        while (next_unskippable_block < nblocks)
        {
            uint8       vmstatus;

            vmstatus = visibilitymap_get_status(onerel, next_unskippable_block,
                                                &vmbuffer);
            if (aggressive)
            {
                if ((vmstatus & VISIBILITYMAP_ALL_FROZEN) == 0)
                    break;
            }
            else
            {
                if ((vmstatus & VISIBILITYMAP_ALL_VISIBLE) == 0)
                    break;
            }
            vacuum_delay_point();
            next_unskippable_block++;
        }
    }

    if (next_unskippable_block >= SKIP_PAGES_THRESHOLD)
        skipping_blocks = true;
    else
        skipping_blocks = false;

    for (blkno = 0; blkno < nblocks; blkno++)
    {
        Buffer      buf;
        Page        page;
        OffsetNumber offnum,
                    maxoff;
        bool        tupgone,
                    hastup;
        int         prev_dead_count;
        int         nfrozen;
        Size        freespace;
        bool        all_visible_according_to_vm = false;
        bool        all_visible;
        bool        all_frozen = true;  /* provided all_visible is also true */
        bool        has_dead_tuples;
        TransactionId visibility_cutoff_xid = InvalidTransactionId;

        /* see note above about forcing scanning of last page */
#define FORCE_CHECK_PAGE() \
        (blkno == nblocks - 1 && should_attempt_truncation(params, vacrelstats))

        pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED, blkno);

        if (blkno == next_unskippable_block)
        {
            /* Time to advance next_unskippable_block */
            next_unskippable_block++;
            if ((params->options & VACOPT_DISABLE_PAGE_SKIPPING) == 0)
            {
                while (next_unskippable_block < nblocks)
                {
                    uint8       vmskipflags;

                    vmskipflags = visibilitymap_get_status(onerel,
                                                           next_unskippable_block,
                                                           &vmbuffer);
                    if (aggressive)
                    {
                        if ((vmskipflags & VISIBILITYMAP_ALL_FROZEN) == 0)
                            break;
                    }
                    else
                    {
                        if ((vmskipflags & VISIBILITYMAP_ALL_VISIBLE) == 0)
                            break;
                    }
                    vacuum_delay_point();
                    next_unskippable_block++;
                }
            }

            /*
             * We know we can't skip the current block.  But set up
             * skipping_blocks to do the right thing at the following blocks.
             */
            if (next_unskippable_block - blkno > SKIP_PAGES_THRESHOLD)
                skipping_blocks = true;
            else
                skipping_blocks = false;

            /*
             * Normally, the fact that we can't skip this block must mean that
             * it's not all-visible.  But in an aggressive vacuum we know only
             * that it's not all-frozen, so it might still be all-visible.
             */
            if (aggressive && VM_ALL_VISIBLE(onerel, blkno, &vmbuffer))
                all_visible_according_to_vm = true;
        }
        else
        {
            /*
             * The current block is potentially skippable; if we've seen a
             * long enough run of skippable blocks to justify skipping it, and
             * we're not forced to check it, then go ahead and skip.
             * Otherwise, the page must be at least all-visible if not
             * all-frozen, so we can set all_visible_according_to_vm = true.
             */
            if (skipping_blocks && !FORCE_CHECK_PAGE())
            {
                /*
                 * Tricky, tricky.  If this is in aggressive vacuum, the page
                 * must have been all-frozen at the time we checked whether it
                 * was skippable, but it might not be any more.  We must be
                 * careful to count it as a skipped all-frozen page in that
                 * case, or else we'll think we can't update relfrozenxid and
                 * relminmxid.  If it's not an aggressive vacuum, we don't
                 * know whether it was all-frozen, so we have to recheck; but
                 * in this case an approximate answer is OK.
                 */
                if (aggressive || VM_ALL_FROZEN(onerel, blkno, &vmbuffer))
                    vacrelstats->frozenskipped_pages++;
                continue;
            }
            all_visible_according_to_vm = true;
        }

        vacuum_delay_point();

        /*
         * If we are close to overrunning the available space for dead-tuple
         * TIDs, pause and do a cycle of vacuuming before we tackle this page.
         */
        if ((dead_tuples->max_tuples - dead_tuples->num_tuples) < MaxHeapTuplesPerPage &&
            dead_tuples->num_tuples > 0)
        {
            /*
             * Before beginning index vacuuming, we release any pin we may
             * hold on the visibility map page.  This isn't necessary for
             * correctness, but we do it anyway to avoid holding the pin
             * across a lengthy, unrelated operation.
             */
            if (BufferIsValid(vmbuffer))
            {
                ReleaseBuffer(vmbuffer);
                vmbuffer = InvalidBuffer;
            }

            /* Work on all the indexes, then the heap */
            lazy_vacuum_all_indexes(onerel, Irel, indstats,
                                    vacrelstats, lps, nindexes);

            /* Remove tuples from heap */
            lazy_vacuum_heap(onerel, vacrelstats);

            /*
             * Forget the now-vacuumed tuples, and press on, but be careful
             * not to reset latestRemovedXid since we want that value to be
             * valid.
             */
            dead_tuples->num_tuples = 0;

            /*
             * Vacuum the Free Space Map to make newly-freed space visible on
             * upper-level FSM pages.  Note we have not yet processed blkno.
             */
            FreeSpaceMapVacuumRange(onerel, next_fsm_block_to_vacuum, blkno);
            next_fsm_block_to_vacuum = blkno;

            /* Report that we are once again scanning the heap */
            pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                         PROGRESS_VACUUM_PHASE_SCAN_HEAP);
        }

        /*
         * Pin the visibility map page in case we need to mark the page
         * all-visible.  In most cases this will be very cheap, because we'll
         * already have the correct page pinned anyway.  However, it's
         * possible that (a) next_unskippable_block is covered by a different
         * VM page than the current block or (b) we released our pin and did a
         * cycle of index vacuuming.
         *
         */
        visibilitymap_pin(onerel, blkno, &vmbuffer);

        buf = ReadBufferExtended(onerel, MAIN_FORKNUM, blkno,
                                 RBM_NORMAL, vac_strategy);

        /* We need buffer cleanup lock so that we can prune HOT chains. */
        if (!ConditionalLockBufferForCleanup(buf))
        {
            /*
             * If we're not performing an aggressive scan to guard against XID
             * wraparound, and we don't want to forcibly check the page, then
             * it's OK to skip vacuuming pages we get a lock conflict on. They
             * will be dealt with in some future vacuum.
             */
            if (!aggressive && !FORCE_CHECK_PAGE())
            {
                ReleaseBuffer(buf);
                vacrelstats->pinskipped_pages++;
                continue;
            }

            /*
             * Read the page with share lock to see if any xids on it need to
             * be frozen.  If not we just skip the page, after updating our
             * scan statistics.  If there are some, we wait for cleanup lock.
             *
             * We could defer the lock request further by remembering the page
             * and coming back to it later, or we could even register
             * ourselves for multiple buffers and then service whichever one
             * is received first.  For now, this seems good enough.
             *
             * If we get here with aggressive false, then we're just forcibly
             * checking the page, and so we don't want to insist on getting
             * the lock; we only need to know if the page contains tuples, so
             * that we can update nonempty_pages correctly.  It's convenient
             * to use lazy_check_needs_freeze() for both situations, though.
             */
            LockBuffer(buf, BUFFER_LOCK_SHARE);
            if (!lazy_check_needs_freeze(buf, &hastup))
            {
                UnlockReleaseBuffer(buf);
                vacrelstats->scanned_pages++;
                vacrelstats->pinskipped_pages++;
                if (hastup)
                    vacrelstats->nonempty_pages = blkno + 1;
                continue;
            }
            if (!aggressive)
            {
                /*
                 * Here, we must not advance scanned_pages; that would amount
                 * to claiming that the page contains no freezable tuples.
                 */
                UnlockReleaseBuffer(buf);
                vacrelstats->pinskipped_pages++;
                if (hastup)
                    vacrelstats->nonempty_pages = blkno + 1;
                continue;
            }
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
            LockBufferForCleanup(buf);
            /* drop through to normal processing */
        }

        vacrelstats->scanned_pages++;
        vacrelstats->tupcount_pages++;

        page = BufferGetPage(buf);

        if (PageIsNew(page))
        {
            bool        still_new;

            /*
             * All-zeroes pages can be left over if either a backend extends
             * the relation by a single page, but crashes before the newly
             * initialized page has been written out, or when bulk-extending
             * the relation (which creates a number of empty pages at the tail
             * end of the relation, but enters them into the FSM).
             *
             * Make sure these pages are in the FSM, to ensure they can be
             * reused. Do that by testing if there's any space recorded for
             * the page. If not, enter it.
             *
             * Note we do not enter the page into the visibilitymap. That has
             * the downside that we repeatedly visit this page in subsequent
             * vacuums, but otherwise we'll never not discover the space on a
             * promoted standby. The harm of repeated checking ought to
             * normally not be too bad - the space usually should be used at
             * some point, otherwise there wouldn't be any regular vacuums.
             */

            /*
             * Perform checking of FSM after releasing lock, the fsm is
             * approximate, after all.
             */
            still_new = PageIsNew(page);
            UnlockReleaseBuffer(buf);

            if (still_new)
            {
                empty_pages++;

                if (GetRecordedFreeSpace(onerel, blkno) == 0)
                {
                    Size        freespace;

                    freespace = BufferGetPageSize(buf) - SizeOfPageHeaderData;
                    RecordPageWithFreeSpace(onerel, blkno, freespace);
                }
            }
            continue;
        }

        if (PageIsEmpty(page))
        {
            empty_pages++;
            freespace = PageGetHeapFreeSpace(page);

            /*
             * Empty pages are always all-visible and all-frozen (note that
             * the same is currently not true for new pages, see above).
             */
            if (!PageIsAllVisible(page))
            {
                START_CRIT_SECTION();

                /* mark buffer dirty before writing a WAL record */
                MarkBufferDirty(buf);

                /*
                 * It's possible that another backend has extended the heap,
                 * initialized the page, and then failed to WAL-log the page
                 * due to an ERROR.  Since heap extension is not WAL-logged,
                 * recovery might try to replay our record setting the page
                 * all-visible and find that the page isn't initialized, which
                 * will cause a PANIC.  To prevent that, check whether the
                 * page has been previously WAL-logged, and if not, do that
                 * now.
                 */
                if (RelationNeedsWAL(onerel) &&
                    PageGetLSN(page) == InvalidXLogRecPtr)
                    log_newpage_buffer(buf, true);

                PageSetAllVisible(page);
                visibilitymap_set(onerel, blkno, buf, InvalidXLogRecPtr,
                                  vmbuffer, InvalidTransactionId,
                                  VISIBILITYMAP_ALL_VISIBLE | VISIBILITYMAP_ALL_FROZEN);
                END_CRIT_SECTION();
            }

            UnlockReleaseBuffer(buf);
            RecordPageWithFreeSpace(onerel, blkno, freespace);
            continue;
        }

        /*
         * Prune all HOT-update chains in this page.
         *
         * We count tuples removed by the pruning step as removed by VACUUM.
         */
        tups_vacuumed += heap_page_prune(onerel, buf, OldestXmin, false,
                                         &vacrelstats->latestRemovedXid);

        /*
         * Now scan the page to collect vacuumable items and check for tuples
         * requiring freezing.
         */
        all_visible = true;
        has_dead_tuples = false;
        nfrozen = 0;
        hastup = false;
        prev_dead_count = dead_tuples->num_tuples;
        maxoff = PageGetMaxOffsetNumber(page);

        /*
         * Note: If you change anything in the loop below, also look at
         * heap_page_is_all_visible to see if that needs to be changed.
         */
        for (offnum = FirstOffsetNumber;
             offnum <= maxoff;
             offnum = OffsetNumberNext(offnum))
        {
            ItemId      itemid;

            itemid = PageGetItemId(page, offnum);

            /* Unused items require no processing, but we count 'em */
            if (!ItemIdIsUsed(itemid))
            {
                nunused += 1;
                continue;
            }

            /* Redirect items mustn't be touched */
            if (ItemIdIsRedirected(itemid))
            {
                hastup = true;  /* this page won't be truncatable */
                continue;
            }

            ItemPointerSet(&(tuple.t_self), blkno, offnum);

            /*
             * DEAD line pointers are to be vacuumed normally; but we don't
             * count them in tups_vacuumed, else we'd be double-counting (at
             * least in the common case where heap_page_prune() just freed up
             * a non-HOT tuple).
             */
            if (ItemIdIsDead(itemid))
            {
                lazy_record_dead_tuple(dead_tuples, &(tuple.t_self));
                all_visible = false;
                continue;
            }

            Assert(ItemIdIsNormal(itemid));

            tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
            tuple.t_len = ItemIdGetLength(itemid);
            tuple.t_tableOid = RelationGetRelid(onerel);

            tupgone = false;

            /*
             * The criteria for counting a tuple as live in this block need to
             * match what analyze.c's acquire_sample_rows() does, otherwise
             * VACUUM and ANALYZE may produce wildly different reltuples
             * values, e.g. when there are many recently-dead tuples.
             *
             * The logic here is a bit simpler than acquire_sample_rows(), as
             * VACUUM can't run inside a transaction block, which makes some
             * cases impossible (e.g. in-progress insert from the same
             * transaction).
             */
            switch (HeapTupleSatisfiesVacuum(&tuple, OldestXmin, buf))
            {
                case HEAPTUPLE_DEAD:

                    /*
                     * Ordinarily, DEAD tuples would have been removed by
                     * heap_page_prune(), but it's possible that the tuple
                     * state changed since heap_page_prune() looked.  In
                     * particular an INSERT_IN_PROGRESS tuple could have
                     * changed to DEAD if the inserter aborted.  So this
                     * cannot be considered an error condition.
                     *
                     * If the tuple is HOT-updated then it must only be
                     * removed by a prune operation; so we keep it just as if
                     * it were RECENTLY_DEAD.  Also, if it's a heap-only
                     * tuple, we choose to keep it, because it'll be a lot
                     * cheaper to get rid of it in the next pruning pass than
                     * to treat it like an indexed tuple. Finally, if index
                     * cleanup is disabled, the second heap pass will not
                     * execute, and the tuple will not get removed, so we must
                     * treat it like any other dead tuple that we choose to
                     * keep.
                     *
                     * If this were to happen for a tuple that actually needed
                     * to be deleted, we'd be in trouble, because it'd
                     * possibly leave a tuple below the relation's xmin
                     * horizon alive.  heap_prepare_freeze_tuple() is prepared
                     * to detect that case and abort the transaction,
                     * preventing corruption.
                     */
                    if (HeapTupleIsHotUpdated(&tuple) ||
                        HeapTupleIsHeapOnly(&tuple) ||
                        params->index_cleanup == VACOPT_TERNARY_DISABLED)
                        nkeep += 1;
                    else
                        tupgone = true; /* we can delete the tuple */
                    all_visible = false;
                    break;
                case HEAPTUPLE_LIVE:

                    /*
                     * Count it as live.  Not only is this natural, but it's
                     * also what acquire_sample_rows() does.
                     */
                    live_tuples += 1;

                    /*
                     * Is the tuple definitely visible to all transactions?
                     *
                     * NB: Like with per-tuple hint bits, we can't set the
                     * PD_ALL_VISIBLE flag if the inserter committed
                     * asynchronously. See SetHintBits for more info. Check
                     * that the tuple is hinted xmin-committed because of
                     * that.
                     */
                    if (all_visible)
                    {
                        TransactionId xmin;

                        if (!HeapTupleHeaderXminCommitted(tuple.t_data))
                        {
                            all_visible = false;
                            break;
                        }

                        /*
                         * The inserter definitely committed. But is it old
                         * enough that everyone sees it as committed?
                         */
                        xmin = HeapTupleHeaderGetXmin(tuple.t_data);
                        if (!TransactionIdPrecedes(xmin, OldestXmin))
                        {
                            all_visible = false;
                            break;
                        }

                        /* Track newest xmin on page. */
                        if (TransactionIdFollows(xmin, visibility_cutoff_xid))
                            visibility_cutoff_xid = xmin;
                    }
                    break;
                case HEAPTUPLE_RECENTLY_DEAD:

                    /*
                     * If tuple is recently deleted then we must not remove it
                     * from relation.
                     */
                    nkeep += 1;
                    all_visible = false;
                    break;
                case HEAPTUPLE_INSERT_IN_PROGRESS:

                    /*
                     * This is an expected case during concurrent vacuum.
                     *
                     * We do not count these rows as live, because we expect
                     * the inserting transaction to update the counters at
                     * commit, and we assume that will happen only after we
                     * report our results.  This assumption is a bit shaky,
                     * but it is what acquire_sample_rows() does, so be
                     * consistent.
                     */
                    all_visible = false;
                    break;
                case HEAPTUPLE_DELETE_IN_PROGRESS:
                    /* This is an expected case during concurrent vacuum */
                    all_visible = false;

                    /*
                     * Count such rows as live.  As above, we assume the
                     * deleting transaction will commit and update the
                     * counters after we report.
                     */
                    live_tuples += 1;
                    break;
                default:
                    elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                    break;
            }

            if (tupgone)
            {
                lazy_record_dead_tuple(dead_tuples, &(tuple.t_self));
                HeapTupleHeaderAdvanceLatestRemovedXid(tuple.t_data,
                                                       &vacrelstats->latestRemovedXid);
                tups_vacuumed += 1;
                has_dead_tuples = true;
            }
            else
            {
                bool        tuple_totally_frozen;

                num_tuples += 1;
                hastup = true;

                /*
                 * Each non-removable tuple must be checked to see if it needs
                 * freezing.  Note we already have exclusive buffer lock.
                 */
                if (heap_prepare_freeze_tuple(tuple.t_data,
                                              relfrozenxid, relminmxid,
                                              FreezeLimit, MultiXactCutoff,
                                              &frozen[nfrozen],
                                              &tuple_totally_frozen))
                    frozen[nfrozen++].offset = offnum;

                if (!tuple_totally_frozen)
                    all_frozen = false;
            }
        }                       /* scan along page */

        /*
         * If we froze any tuples, mark the buffer dirty, and write a WAL
         * record recording the changes.  We must log the changes to be
         * crash-safe against future truncation of CLOG.
         */
        if (nfrozen > 0)
        {
            START_CRIT_SECTION();

            MarkBufferDirty(buf);

            /* execute collected freezes */
            for (i = 0; i < nfrozen; i++)
            {
                ItemId      itemid;
                HeapTupleHeader htup;

                itemid = PageGetItemId(page, frozen[i].offset);
                htup = (HeapTupleHeader) PageGetItem(page, itemid);

                heap_execute_freeze_tuple(htup, &frozen[i]);
            }

            /* Now WAL-log freezing if necessary */
            if (RelationNeedsWAL(onerel))
            {
                XLogRecPtr  recptr;

                recptr = log_heap_freeze(onerel, buf, FreezeLimit,
                                         frozen, nfrozen);
                PageSetLSN(page, recptr);
            }

            END_CRIT_SECTION();
        }

        /*
         * If there are no indexes we can vacuum the page right now instead of
         * doing a second scan. Also we don't do that but forget dead tuples
         * when index cleanup is disabled.
         */
        if (!vacrelstats->useindex && dead_tuples->num_tuples > 0)
        {
            if (nindexes == 0)
            {
                /* Remove tuples from heap if the table has no index */
                lazy_vacuum_page(onerel, blkno, buf, 0, vacrelstats, &vmbuffer);
                vacuumed_pages++;
                has_dead_tuples = false;
            }
            else
            {
                /*
                 * Here, we have indexes but index cleanup is disabled.
                 * Instead of vacuuming the dead tuples on the heap, we just
                 * forget them.
                 *
                 * Note that vacrelstats->dead_tuples could have tuples which
                 * became dead after HOT-pruning but are not marked dead yet.
                 * We do not process them because it's a very rare condition,
                 * and the next vacuum will process them anyway.
                 */
                Assert(params->index_cleanup == VACOPT_TERNARY_DISABLED);
            }

            /*
             * Forget the now-vacuumed tuples, and press on, but be careful
             * not to reset latestRemovedXid since we want that value to be
             * valid.
             */
            dead_tuples->num_tuples = 0;

            /*
             * Periodically do incremental FSM vacuuming to make newly-freed
             * space visible on upper FSM pages.  Note: although we've cleaned
             * the current block, we haven't yet updated its FSM entry (that
             * happens further down), so passing end == blkno is correct.
             */
            if (blkno - next_fsm_block_to_vacuum >= VACUUM_FSM_EVERY_PAGES)
            {
                FreeSpaceMapVacuumRange(onerel, next_fsm_block_to_vacuum,
                                        blkno);
                next_fsm_block_to_vacuum = blkno;
            }
        }

        freespace = PageGetHeapFreeSpace(page);

        /* mark page all-visible, if appropriate */
        if (all_visible && !all_visible_according_to_vm)
        {
            uint8       flags = VISIBILITYMAP_ALL_VISIBLE;

            if (all_frozen)
                flags |= VISIBILITYMAP_ALL_FROZEN;

            /*
             * It should never be the case that the visibility map page is set
             * while the page-level bit is clear, but the reverse is allowed
             * (if checksums are not enabled).  Regardless, set both bits so
             * that we get back in sync.
             *
             * NB: If the heap page is all-visible but the VM bit is not set,
             * we don't need to dirty the heap page.  However, if checksums
             * are enabled, we do need to make sure that the heap page is
             * dirtied before passing it to visibilitymap_set(), because it
             * may be logged.  Given that this situation should only happen in
             * rare cases after a crash, it is not worth optimizing.
             */
            PageSetAllVisible(page);
            MarkBufferDirty(buf);
            visibilitymap_set(onerel, blkno, buf, InvalidXLogRecPtr,
                              vmbuffer, visibility_cutoff_xid, flags);
        }

        /*
         * As of PostgreSQL 9.2, the visibility map bit should never be set if
         * the page-level bit is clear.  However, it's possible that the bit
         * got cleared after we checked it and before we took the buffer
         * content lock, so we must recheck before jumping to the conclusion
         * that something bad has happened.
         */
        else if (all_visible_according_to_vm && !PageIsAllVisible(page)
                 && VM_ALL_VISIBLE(onerel, blkno, &vmbuffer))
        {
            elog(WARNING, "page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
                 relname, blkno);
            visibilitymap_clear(onerel, blkno, vmbuffer,
                                VISIBILITYMAP_VALID_BITS);
        }

        /*
         * It's possible for the value returned by GetOldestXmin() to move
         * backwards, so it's not wrong for us to see tuples that appear to
         * not be visible to everyone yet, while PD_ALL_VISIBLE is already
         * set. The real safe xmin value never moves backwards, but
         * GetOldestXmin() is conservative and sometimes returns a value
         * that's unnecessarily small, so if we see that contradiction it just
         * means that the tuples that we think are not visible to everyone yet
         * actually are, and the PD_ALL_VISIBLE flag is correct.
         *
         * There should never be dead tuples on a page with PD_ALL_VISIBLE
         * set, however.
         */
        else if (PageIsAllVisible(page) && has_dead_tuples)
        {
            elog(WARNING, "page containing dead tuples is marked as all-visible in relation \"%s\" page %u",
                 relname, blkno);
            PageClearAllVisible(page);
            MarkBufferDirty(buf);
            visibilitymap_clear(onerel, blkno, vmbuffer,
                                VISIBILITYMAP_VALID_BITS);
        }

        /*
         * If the all-visible page is all-frozen but not marked as such yet,
         * mark it as all-frozen.  Note that all_frozen is only valid if
         * all_visible is true, so we must check both.
         */
        else if (all_visible_according_to_vm && all_visible && all_frozen &&
                 !VM_ALL_FROZEN(onerel, blkno, &vmbuffer))
        {
            /*
             * We can pass InvalidTransactionId as the cutoff XID here,
             * because setting the all-frozen bit doesn't cause recovery
             * conflicts.
             */
            visibilitymap_set(onerel, blkno, buf, InvalidXLogRecPtr,
                              vmbuffer, InvalidTransactionId,
                              VISIBILITYMAP_ALL_FROZEN);
        }

        UnlockReleaseBuffer(buf);

        /* Remember the location of the last page with nonremovable tuples */
        if (hastup)
            vacrelstats->nonempty_pages = blkno + 1;

        /*
         * If we remembered any tuples for deletion, then the page will be
         * visited again by lazy_vacuum_heap, which will compute and record
         * its post-compaction free space.  If not, then we're done with this
         * page, so remember its free space as-is.  (This path will always be
         * taken if there are no indexes.)
         */
        if (dead_tuples->num_tuples == prev_dead_count)
            RecordPageWithFreeSpace(onerel, blkno, freespace);
    }

    /* report that everything is scanned and vacuumed */
    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED, blkno);

    pfree(frozen);

    /* save stats for use later */
    vacrelstats->tuples_deleted = tups_vacuumed;
    vacrelstats->new_dead_tuples = nkeep;

    /* now we can compute the new value for pg_class.reltuples */
    vacrelstats->new_live_tuples = vac_estimate_reltuples(onerel,
                                                          nblocks,
                                                          vacrelstats->tupcount_pages,
                                                          live_tuples);

    /* also compute total number of surviving heap entries */
    vacrelstats->new_rel_tuples =
        vacrelstats->new_live_tuples + vacrelstats->new_dead_tuples;

    /*
     * Release any remaining pin on visibility map page.
     */
    if (BufferIsValid(vmbuffer))
    {
        ReleaseBuffer(vmbuffer);
        vmbuffer = InvalidBuffer;
    }

    /* If any tuples need to be deleted, perform final vacuum cycle */
    /* XXX put a threshold on min number of tuples here? */
    if (dead_tuples->num_tuples > 0)
    {
        /* Work on all the indexes, and then the heap */
        lazy_vacuum_all_indexes(onerel, Irel, indstats, vacrelstats,
                                lps, nindexes);

        /* Remove tuples from heap */
        lazy_vacuum_heap(onerel, vacrelstats);
    }

    /*
     * Vacuum the remainder of the Free Space Map.  We must do this whether or
     * not there were indexes.
     */
    if (blkno > next_fsm_block_to_vacuum)
        FreeSpaceMapVacuumRange(onerel, next_fsm_block_to_vacuum, blkno);

    /* report all blocks vacuumed */
    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, blkno);

    /* Do post-vacuum cleanup */
    if (vacrelstats->useindex)
        lazy_cleanup_all_indexes(Irel, indstats, vacrelstats, lps, nindexes);

    /*
     * End parallel mode before updating index statistics as we cannot write
     * during parallel mode.
     */
    if (ParallelVacuumIsActive(lps))
        end_parallel_vacuum(Irel, indstats, lps, nindexes);

    /* Update index statistics */
    update_index_statistics(Irel, indstats, nindexes);

    /* If no indexes, make log report that lazy_vacuum_heap would've made */
    if (vacuumed_pages)
        ereport(elevel,
                (errmsg("\"%s\": removed %.0f row versions in %u pages",
                        RelationGetRelationName(onerel),
                        tups_vacuumed, vacuumed_pages)));

    /*
     * This is pretty messy, but we split it up so that we can skip emitting
     * individual parts of the message when not applicable.
     */
    initStringInfo(&buf);
    appendStringInfo(&buf,
                     _("%.0f dead row versions cannot be removed yet, oldest xmin: %u\n"),
                     nkeep, OldestXmin);
    appendStringInfo(&buf, _("There were %.0f unused item identifiers.\n"),
                     nunused);
    appendStringInfo(&buf, ngettext("Skipped %u page due to buffer pins, ",
                                    "Skipped %u pages due to buffer pins, ",
                                    vacrelstats->pinskipped_pages),
                     vacrelstats->pinskipped_pages);
    appendStringInfo(&buf, ngettext("%u frozen page.\n",
                                    "%u frozen pages.\n",
                                    vacrelstats->frozenskipped_pages),
                     vacrelstats->frozenskipped_pages);
    appendStringInfo(&buf, ngettext("%u page is entirely empty.\n",
                                    "%u pages are entirely empty.\n",
                                    empty_pages),
                     empty_pages);
    appendStringInfo(&buf, _("%s."), pg_rusage_show(&ru0));

    ereport(elevel,
            (errmsg("\"%s\": found %.0f removable, %.0f nonremovable row versions in %u out of %u pages",
                    RelationGetRelationName(onerel),
                    tups_vacuumed, num_tuples,
                    vacrelstats->scanned_pages, nblocks),
             errdetail_internal("%s", buf.data)));
    pfree(buf.data);
}

lazy_space_alloc()

static void lazy_space_alloc ( LVRelStats *  vacrelstats, BlockNumber  relblocks  )

static

Definition at line 2738 of file vacuumlazy.c.

References compute_max_dead_tuples(), LVRelStats::dead_tuples, LVDeadTuples::max_tuples, LVDeadTuples::num_tuples, palloc(), SizeOfDeadTuples, and LVRelStats::useindex.

Referenced by lazy_scan_heap().

{
    LVDeadTuples *dead_tuples = NULL;
    long        maxtuples;

    maxtuples = compute_max_dead_tuples(relblocks, vacrelstats->useindex);

    dead_tuples = (LVDeadTuples *) palloc(SizeOfDeadTuples(maxtuples));
    dead_tuples->num_tuples = 0;
    dead_tuples->max_tuples = (int) maxtuples;

    vacrelstats->dead_tuples = dead_tuples;
}

lazy_tid_reaped()

static bool lazy_tid_reaped ( ItemPointer  itemptr, void *  state  )

static

Definition at line 2780 of file vacuumlazy.c.

References LVDeadTuples::itemptrs, LVDeadTuples::num_tuples, and vac_cmp_itemptr().

Referenced by lazy_vacuum_index().

{
    LVDeadTuples *dead_tuples = (LVDeadTuples *) state;
    ItemPointer res;

    res = (ItemPointer) bsearch((void *) itemptr,
                                (void *) dead_tuples->itemptrs,
                                dead_tuples->num_tuples,
                                sizeof(ItemPointerData),
                                vac_cmp_itemptr);

    return (res != NULL);
}

lazy_truncate_heap()

static void lazy_truncate_heap ( Relation  onerel, LVRelStats *  vacrelstats  )

static

Definition at line 2438 of file vacuumlazy.c.

References AccessExclusiveLock, CHECK_FOR_INTERRUPTS, ConditionalLockRelation(), count_nondeletable_pages(), elevel, ereport, errdetail_internal(), errmsg(), LVRelStats::lock_waiter_detected, LVRelStats::nonempty_pages, LVRelStats::pages_removed, pg_rusage_init(), pg_rusage_show(), pg_usleep(), pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_TRUNCATE, LVRelStats::rel_pages, RelationGetNumberOfBlocks, RelationGetRelationName, RelationTruncate(), UnlockRelation(), VACUUM_TRUNCATE_LOCK_TIMEOUT, and VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL.

Referenced by heap_vacuum_rel().

{
    BlockNumber old_rel_pages = vacrelstats->rel_pages;
    BlockNumber new_rel_pages;
    int         lock_retry;

    /* Report that we are now truncating */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_TRUNCATE);

    /*
     * Loop until no more truncating can be done.
     */
    do
    {
        PGRUsage    ru0;

        pg_rusage_init(&ru0);

        /*
         * We need full exclusive lock on the relation in order to do
         * truncation. If we can't get it, give up rather than waiting --- we
         * don't want to block other backends, and we don't want to deadlock
         * (which is quite possible considering we already hold a lower-grade
         * lock).
         */
        vacrelstats->lock_waiter_detected = false;
        lock_retry = 0;
        while (true)
        {
            if (ConditionalLockRelation(onerel, AccessExclusiveLock))
                break;

            /*
             * Check for interrupts while trying to (re-)acquire the exclusive
             * lock.
             */
            CHECK_FOR_INTERRUPTS();

            if (++lock_retry > (VACUUM_TRUNCATE_LOCK_TIMEOUT /
                                VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL))
            {
                /*
                 * We failed to establish the lock in the specified number of
                 * retries. This means we give up truncating.
                 */
                vacrelstats->lock_waiter_detected = true;
                ereport(elevel,
                        (errmsg("\"%s\": stopping truncate due to conflicting lock request",
                                RelationGetRelationName(onerel))));
                return;
            }

            pg_usleep(VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL * 1000L);
        }

        /*
         * Now that we have exclusive lock, look to see if the rel has grown
         * whilst we were vacuuming with non-exclusive lock.  If so, give up;
         * the newly added pages presumably contain non-deletable tuples.
         */
        new_rel_pages = RelationGetNumberOfBlocks(onerel);
        if (new_rel_pages != old_rel_pages)
        {
            /*
             * Note: we intentionally don't update vacrelstats->rel_pages with
             * the new rel size here.  If we did, it would amount to assuming
             * that the new pages are empty, which is unlikely. Leaving the
             * numbers alone amounts to assuming that the new pages have the
             * same tuple density as existing ones, which is less unlikely.
             */
            UnlockRelation(onerel, AccessExclusiveLock);
            return;
        }

        /*
         * Scan backwards from the end to verify that the end pages actually
         * contain no tuples.  This is *necessary*, not optional, because
         * other backends could have added tuples to these pages whilst we
         * were vacuuming.
         */
        new_rel_pages = count_nondeletable_pages(onerel, vacrelstats);

        if (new_rel_pages >= old_rel_pages)
        {
            /* can't do anything after all */
            UnlockRelation(onerel, AccessExclusiveLock);
            return;
        }

        /*
         * Okay to truncate.
         */
        RelationTruncate(onerel, new_rel_pages);

        /*
         * We can release the exclusive lock as soon as we have truncated.
         * Other backends can't safely access the relation until they have
         * processed the smgr invalidation that smgrtruncate sent out ... but
         * that should happen as part of standard invalidation processing once
         * they acquire lock on the relation.
         */
        UnlockRelation(onerel, AccessExclusiveLock);

        /*
         * Update statistics.  Here, it *is* correct to adjust rel_pages
         * without also touching reltuples, since the tuple count wasn't
         * changed by the truncation.
         */
        vacrelstats->pages_removed += old_rel_pages - new_rel_pages;
        vacrelstats->rel_pages = new_rel_pages;

        ereport(elevel,
                (errmsg("\"%s\": truncated %u to %u pages",
                        RelationGetRelationName(onerel),
                        old_rel_pages, new_rel_pages),
                 errdetail_internal("%s",
                                    pg_rusage_show(&ru0))));
        old_rel_pages = new_rel_pages;
    } while (new_rel_pages > vacrelstats->nonempty_pages &&
             vacrelstats->lock_waiter_detected);
}

lazy_vacuum_all_indexes()

static void lazy_vacuum_all_indexes ( Relation  onerel, Relation *  Irel, IndexBulkDeleteResult **  stats, LVRelStats *  vacrelstats, LVParallelState *  lps, int  nindexes  )

static

Definition at line 1710 of file vacuumlazy.c.

References Assert, LVRelStats::dead_tuples, LVShared::estimated_count, LVShared::first_time, LVShared::for_cleanup, idx(), IsParallelWorker, lazy_parallel_vacuum_indexes(), lazy_vacuum_index(), LVParallelState::lvshared, LVRelStats::num_index_scans, LVRelStats::old_live_tuples, ParallelVacuumIsActive, pgstat_progress_update_param(), PROGRESS_VACUUM_NUM_INDEX_VACUUMS, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_INDEX, LVShared::reltuples, and vacuum_log_cleanup_info().

Referenced by lazy_scan_heap().

{
    Assert(!IsParallelWorker());
    Assert(nindexes > 0);

    /* Log cleanup info before we touch indexes */
    vacuum_log_cleanup_info(onerel, vacrelstats);

    /* Report that we are now vacuuming indexes */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_VACUUM_INDEX);

    /* Perform index vacuuming with parallel workers for parallel vacuum. */
    if (ParallelVacuumIsActive(lps))
    {
        /* Tell parallel workers to do index vacuuming */
        lps->lvshared->for_cleanup = false;
        lps->lvshared->first_time = false;

        /*
         * We can only provide an approximate value of num_heap_tuples in
         * vacuum cases.
         */
        lps->lvshared->reltuples = vacrelstats->old_live_tuples;
        lps->lvshared->estimated_count = true;

        lazy_parallel_vacuum_indexes(Irel, stats, vacrelstats, lps, nindexes);
    }
    else
    {
        int         idx;

        for (idx = 0; idx < nindexes; idx++)
            lazy_vacuum_index(Irel[idx], &stats[idx], vacrelstats->dead_tuples,
                              vacrelstats->old_live_tuples);
    }

    /* Increase and report the number of index scans */
    vacrelstats->num_index_scans++;
    pgstat_progress_update_param(PROGRESS_VACUUM_NUM_INDEX_VACUUMS,
                                 vacrelstats->num_index_scans);
}

lazy_vacuum_heap()

static void lazy_vacuum_heap ( Relation  onerel, LVRelStats *  vacrelstats  )

static

Definition at line 1769 of file vacuumlazy.c.

References buf, BufferGetPage, BufferIsValid, ConditionalLockBufferForCleanup(), LVRelStats::dead_tuples, elevel, ereport, errdetail_internal(), errmsg(), InvalidBuffer, ItemPointerGetBlockNumber, LVDeadTuples::itemptrs, lazy_vacuum_page(), MAIN_FORKNUM, PageGetHeapFreeSpace(), pg_rusage_init(), pg_rusage_show(), pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_HEAP, RBM_NORMAL, ReadBufferExtended(), RecordPageWithFreeSpace(), RelationGetRelationName, ReleaseBuffer(), UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by lazy_scan_heap().

{
    int         tupindex;
    int         npages;
    PGRUsage    ru0;
    Buffer      vmbuffer = InvalidBuffer;

    /* Report that we are now vacuuming the heap */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_VACUUM_HEAP);

    pg_rusage_init(&ru0);
    npages = 0;

    tupindex = 0;
    while (tupindex < vacrelstats->dead_tuples->num_tuples)
    {
        BlockNumber tblk;
        Buffer      buf;
        Page        page;
        Size        freespace;

        vacuum_delay_point();

        tblk = ItemPointerGetBlockNumber(&vacrelstats->dead_tuples->itemptrs[tupindex]);
        buf = ReadBufferExtended(onerel, MAIN_FORKNUM, tblk, RBM_NORMAL,
                                 vac_strategy);
        if (!ConditionalLockBufferForCleanup(buf))
        {
            ReleaseBuffer(buf);
            ++tupindex;
            continue;
        }
        tupindex = lazy_vacuum_page(onerel, tblk, buf, tupindex, vacrelstats,
                                    &vmbuffer);

        /* Now that we've compacted the page, record its available space */
        page = BufferGetPage(buf);
        freespace = PageGetHeapFreeSpace(page);

        UnlockReleaseBuffer(buf);
        RecordPageWithFreeSpace(onerel, tblk, freespace);
        npages++;
    }

    if (BufferIsValid(vmbuffer))
    {
        ReleaseBuffer(vmbuffer);
        vmbuffer = InvalidBuffer;
    }

    ereport(elevel,
            (errmsg("\"%s\": removed %d row versions in %d pages",
                    RelationGetRelationName(onerel),
                    tupindex, npages),
             errdetail_internal("%s", pg_rusage_show(&ru0))));
}

lazy_vacuum_index()

static void lazy_vacuum_index ( Relation  indrel, IndexBulkDeleteResult **  stats, LVDeadTuples *  dead_tuples, double  reltuples  )

static

Definition at line 2315 of file vacuumlazy.c.

References IndexVacuumInfo::analyze_only, elevel, ereport, errdetail_internal(), errmsg(), IndexVacuumInfo::estimated_count, gettext_noop, IndexVacuumInfo::index, index_bulk_delete(), IsParallelWorker, lazy_tid_reaped(), IndexVacuumInfo::message_level, IndexVacuumInfo::num_heap_tuples, pg_rusage_init(), pg_rusage_show(), RelationGetRelationName, IndexVacuumInfo::report_progress, IndexVacuumInfo::strategy, and vac_strategy.

Referenced by lazy_vacuum_all_indexes(), and vacuum_one_index().

{
    IndexVacuumInfo ivinfo;
    const char *msg;
    PGRUsage    ru0;

    pg_rusage_init(&ru0);

    ivinfo.index = indrel;
    ivinfo.analyze_only = false;
    ivinfo.report_progress = false;
    ivinfo.estimated_count = true;
    ivinfo.message_level = elevel;
    ivinfo.num_heap_tuples = reltuples;
    ivinfo.strategy = vac_strategy;

    /* Do bulk deletion */
    *stats = index_bulk_delete(&ivinfo, *stats,
                               lazy_tid_reaped, (void *) dead_tuples);

    if (IsParallelWorker())
        msg = gettext_noop("scanned index \"%s\" to remove %d row versions by parallel vacuum worker");
    else
        msg = gettext_noop("scanned index \"%s\" to remove %d row versions");

    ereport(elevel,
            (errmsg(msg,
                    RelationGetRelationName(indrel),
                    dead_tuples->num_tuples),
             errdetail_internal("%s", pg_rusage_show(&ru0))));
}

lazy_vacuum_page()

static int lazy_vacuum_page ( Relation  onerel, BlockNumber  blkno, Buffer  buffer, int  tupindex, LVRelStats *  vacrelstats, Buffer *  vmbuffer  )

static

Definition at line 1838 of file vacuumlazy.c.

References Assert, BufferGetPage, BufferIsValid, LVRelStats::dead_tuples, END_CRIT_SECTION, heap_page_is_all_visible(), InvalidXLogRecPtr, ItemIdSetUnused, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LVDeadTuples::itemptrs, LVRelStats::latestRemovedXid, log_heap_clean(), MarkBufferDirty(), MaxOffsetNumber, LVDeadTuples::num_tuples, PageGetItemId, PageIsAllVisible, PageRepairFragmentation(), PageSetAllVisible, PageSetLSN, pgstat_progress_update_param(), PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, RelationNeedsWAL, START_CRIT_SECTION, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_get_status(), and visibilitymap_set().

Referenced by lazy_scan_heap(), and lazy_vacuum_heap().

{
    LVDeadTuples *dead_tuples = vacrelstats->dead_tuples;
    Page        page = BufferGetPage(buffer);
    OffsetNumber unused[MaxOffsetNumber];
    int         uncnt = 0;
    TransactionId visibility_cutoff_xid;
    bool        all_frozen;

    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, blkno);

    START_CRIT_SECTION();

    for (; tupindex < dead_tuples->num_tuples; tupindex++)
    {
        BlockNumber tblk;
        OffsetNumber toff;
        ItemId      itemid;

        tblk = ItemPointerGetBlockNumber(&dead_tuples->itemptrs[tupindex]);
        if (tblk != blkno)
            break;              /* past end of tuples for this block */
        toff = ItemPointerGetOffsetNumber(&dead_tuples->itemptrs[tupindex]);
        itemid = PageGetItemId(page, toff);
        ItemIdSetUnused(itemid);
        unused[uncnt++] = toff;
    }

    PageRepairFragmentation(page);

    /*
     * Mark buffer dirty before we write WAL.
     */
    MarkBufferDirty(buffer);

    /* XLOG stuff */
    if (RelationNeedsWAL(onerel))
    {
        XLogRecPtr  recptr;

        recptr = log_heap_clean(onerel, buffer,
                                NULL, 0, NULL, 0,
                                unused, uncnt,
                                vacrelstats->latestRemovedXid);
        PageSetLSN(page, recptr);
    }

    /*
     * End critical section, so we safely can do visibility tests (which
     * possibly need to perform IO and allocate memory!). If we crash now the
     * page (including the corresponding vm bit) might not be marked all
     * visible, but that's fine. A later vacuum will fix that.
     */
    END_CRIT_SECTION();

    /*
     * Now that we have removed the dead tuples from the page, once again
     * check if the page has become all-visible.  The page is already marked
     * dirty, exclusively locked, and, if needed, a full page image has been
     * emitted in the log_heap_clean() above.
     */
    if (heap_page_is_all_visible(onerel, buffer, &visibility_cutoff_xid,
                                 &all_frozen))
        PageSetAllVisible(page);

    /*
     * All the changes to the heap page have been done. If the all-visible
     * flag is now set, also set the VM all-visible bit (and, if possible, the
     * all-frozen bit) unless this has already been done previously.
     */
    if (PageIsAllVisible(page))
    {
        uint8       vm_status = visibilitymap_get_status(onerel, blkno, vmbuffer);
        uint8       flags = 0;

        /* Set the VM all-frozen bit to flag, if needed */
        if ((vm_status & VISIBILITYMAP_ALL_VISIBLE) == 0)
            flags |= VISIBILITYMAP_ALL_VISIBLE;
        if ((vm_status & VISIBILITYMAP_ALL_FROZEN) == 0 && all_frozen)
            flags |= VISIBILITYMAP_ALL_FROZEN;

        Assert(BufferIsValid(*vmbuffer));
        if (flags != 0)
            visibilitymap_set(onerel, blkno, buffer, InvalidXLogRecPtr,
                              *vmbuffer, visibility_cutoff_xid, flags);
    }

    return tupindex;
}

parallel_vacuum_index()

static void parallel_vacuum_index ( Relation *  Irel, IndexBulkDeleteResult **  stats, LVShared *  lvshared, LVDeadTuples *  dead_tuples, int  nindexes  )

static

Definition at line 2107 of file vacuumlazy.c.

References get_indstats(), LVShared::idx, idx(), pg_atomic_add_fetch_u32(), pg_atomic_fetch_add_u32(), pg_atomic_sub_fetch_u32(), skip_parallel_vacuum_index(), vacuum_one_index(), and VacuumActiveNWorkers.

Referenced by lazy_parallel_vacuum_indexes(), and parallel_vacuum_main().

{
    /*
     * Increment the active worker count if we are able to launch any worker.
     */
    if (VacuumActiveNWorkers)
        pg_atomic_add_fetch_u32(VacuumActiveNWorkers, 1);

    /* Loop until all indexes are vacuumed */
    for (;;)
    {
        int         idx;
        LVSharedIndStats *shared_indstats;

        /* Get an index number to process */
        idx = pg_atomic_fetch_add_u32(&(lvshared->idx), 1);

        /* Done for all indexes? */
        if (idx >= nindexes)
            break;

        /* Get the index statistics of this index from DSM */
        shared_indstats = get_indstats(lvshared, idx);

        /*
         * Skip processing indexes that doesn't participate in parallel
         * operation
         */
        if (shared_indstats == NULL ||
            skip_parallel_vacuum_index(Irel[idx], lvshared))
            continue;

        /* Do vacuum or cleanup of the index */
        vacuum_one_index(Irel[idx], &(stats[idx]), lvshared, shared_indstats,
                         dead_tuples);
    }

    /*
     * We have completed the index vacuum so decrement the active worker
     * count.
     */
    if (VacuumActiveNWorkers)
        pg_atomic_sub_fetch_u32(VacuumActiveNWorkers, 1);
}

parallel_vacuum_main()

void parallel_vacuum_main	(	dsm_segment *	seg,
		shm_toc *	toc
	)

Definition at line 3314 of file vacuumlazy.c.

References LVShared::active_nworkers, Assert, LVShared::cost_balance, DEBUG1, debug_query_string, LVShared::elevel, elevel, ereport, errmsg(), LVShared::for_cleanup, maintenance_work_mem, LVShared::maintenance_work_mem_worker, palloc0(), parallel_vacuum_index(), PARALLEL_VACUUM_KEY_DEAD_TUPLES, PARALLEL_VACUUM_KEY_QUERY_TEXT, PARALLEL_VACUUM_KEY_SHARED, pfree(), pgstat_report_activity(), LVShared::relid, RowExclusiveLock, ShareUpdateExclusiveLock, shm_toc_lookup(), STATE_RUNNING, table_close(), table_open(), vac_close_indexes(), vac_open_indexes(), VacuumActiveNWorkers, VacuumCostActive, VacuumCostBalance, VacuumCostBalanceLocal, VacuumCostDelay, VacuumPageDirty, VacuumPageHit, VacuumPageMiss, and VacuumSharedCostBalance.

{
    Relation    onerel;
    Relation   *indrels;
    LVShared   *lvshared;
    LVDeadTuples *dead_tuples;
    int         nindexes;
    char       *sharedquery;
    IndexBulkDeleteResult **stats;

    lvshared = (LVShared *) shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_SHARED,
                                           false);
    elevel = lvshared->elevel;

    ereport(DEBUG1,
            (errmsg("starting parallel vacuum worker for %s",
                    lvshared->for_cleanup ? "cleanup" : "bulk delete")));

    /* Set debug_query_string for individual workers */
    sharedquery = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_QUERY_TEXT, false);
    debug_query_string = sharedquery;
    pgstat_report_activity(STATE_RUNNING, debug_query_string);

    /*
     * Open table.  The lock mode is the same as the leader process.  It's
     * okay because the lock mode does not conflict among the parallel
     * workers.
     */
    onerel = table_open(lvshared->relid, ShareUpdateExclusiveLock);

    /*
     * Open all indexes. indrels are sorted in order by OID, which should be
     * matched to the leader's one.
     */
    vac_open_indexes(onerel, RowExclusiveLock, &nindexes, &indrels);
    Assert(nindexes > 0);

    /* Set dead tuple space */
    dead_tuples = (LVDeadTuples *) shm_toc_lookup(toc,
                                                  PARALLEL_VACUUM_KEY_DEAD_TUPLES,
                                                  false);

    /* Set cost-based vacuum delay */
    VacuumCostActive = (VacuumCostDelay > 0);
    VacuumCostBalance = 0;
    VacuumPageHit = 0;
    VacuumPageMiss = 0;
    VacuumPageDirty = 0;
    VacuumCostBalanceLocal = 0;
    VacuumSharedCostBalance = &(lvshared->cost_balance);
    VacuumActiveNWorkers = &(lvshared->active_nworkers);

    stats = (IndexBulkDeleteResult **)
        palloc0(nindexes * sizeof(IndexBulkDeleteResult *));

    if (lvshared->maintenance_work_mem_worker > 0)
        maintenance_work_mem = lvshared->maintenance_work_mem_worker;

    /* Process indexes to perform vacuum/cleanup */
    parallel_vacuum_index(indrels, stats, lvshared, dead_tuples, nindexes);

    vac_close_indexes(nindexes, indrels, RowExclusiveLock);
    table_close(onerel, ShareUpdateExclusiveLock);
    pfree(stats);
}

prepare_index_statistics()

static void prepare_index_statistics ( LVShared *  lvshared, bool *  can_parallel_vacuum, int  nindexes  )

static

Definition at line 3011 of file vacuumlazy.c.

References Assert, LVShared::bitmap, BITMAPLEN, i, and IsAutoVacuumWorkerProcess().

Referenced by begin_parallel_vacuum().

{
    int         i;

    /* Currently, we don't support parallel vacuum for autovacuum */
    Assert(!IsAutoVacuumWorkerProcess());

    /* Set NULL for all indexes */
    memset(lvshared->bitmap, 0x00, BITMAPLEN(nindexes));

    for (i = 0; i < nindexes; i++)
    {
        if (!can_parallel_vacuum[i])
            continue;

        /* Set NOT NULL as this index do support parallelism */
        lvshared->bitmap[i >> 3] |= 1 << (i & 0x07);
    }
}

should_attempt_truncation()

static bool should_attempt_truncation ( VacuumParams *  params, LVRelStats *  vacrelstats  )

static

Definition at line 2417 of file vacuumlazy.c.

References LVRelStats::nonempty_pages, old_snapshot_threshold, LVRelStats::rel_pages, REL_TRUNCATE_FRACTION, REL_TRUNCATE_MINIMUM, VacuumParams::truncate, and VACOPT_TERNARY_DISABLED.

Referenced by heap_vacuum_rel().

{
    BlockNumber possibly_freeable;

    if (params->truncate == VACOPT_TERNARY_DISABLED)
        return false;

    possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
    if (possibly_freeable > 0 &&
        (possibly_freeable >= REL_TRUNCATE_MINIMUM ||
         possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION) &&
        old_snapshot_threshold < 0)
        return true;
    else
        return false;
}

skip_parallel_vacuum_index()

static bool skip_parallel_vacuum_index ( Relation  indrel, LVShared *  lvshared  )

static

Definition at line 3274 of file vacuumlazy.c.

References IndexAmRoutine::amparallelvacuumoptions, Assert, LVShared::first_time, LVShared::for_cleanup, RelationData::rd_indam, VACUUM_OPTION_PARALLEL_BULKDEL, VACUUM_OPTION_PARALLEL_CLEANUP, and VACUUM_OPTION_PARALLEL_COND_CLEANUP.

Referenced by parallel_vacuum_index(), and vacuum_indexes_leader().

{
    uint8       vacoptions = indrel->rd_indam->amparallelvacuumoptions;

    /* first_time must be true only if for_cleanup is true */
    Assert(lvshared->for_cleanup || !lvshared->first_time);

    if (lvshared->for_cleanup)
    {
        /* Skip, if the index does not support parallel cleanup */
        if (((vacoptions & VACUUM_OPTION_PARALLEL_CLEANUP) == 0) &&
            ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) == 0))
            return true;

        /*
         * Skip, if the index supports parallel cleanup conditionally, but we
         * have already processed the index (for bulkdelete).  See the
         * comments for option VACUUM_OPTION_PARALLEL_COND_CLEANUP to know
         * when indexes support parallel cleanup conditionally.
         */
        if (!lvshared->first_time &&
            ((vacoptions & VACUUM_OPTION_PARALLEL_COND_CLEANUP) != 0))
            return true;
    }
    else if ((vacoptions & VACUUM_OPTION_PARALLEL_BULKDEL) == 0)
    {
        /* Skip if the index does not support parallel bulk deletion */
        return true;
    }

    return false;
}

update_index_statistics()

static void update_index_statistics ( Relation *  Irel, IndexBulkDeleteResult **  stats, int  nindexes  )

static

Definition at line 3036 of file vacuumlazy.c.

References Assert, i, InvalidMultiXactId, InvalidTransactionId, IsInParallelMode(), pfree(), and vac_update_relstats().

Referenced by lazy_scan_heap().

{
    int         i;

    Assert(!IsInParallelMode());

    for (i = 0; i < nindexes; i++)
    {
        if (stats[i] == NULL || stats[i]->estimated_count)
            continue;

        /* Update index statistics */
        vac_update_relstats(Irel[i],
                            stats[i]->num_pages,
                            stats[i]->num_index_tuples,
                            0,
                            false,
                            InvalidTransactionId,
                            InvalidMultiXactId,
                            false);
        pfree(stats[i]);
    }
}

vac_cmp_itemptr()

static int vac_cmp_itemptr ( const void *  left, const void *  right  )

static

Definition at line 2798 of file vacuumlazy.c.

References ItemPointerGetBlockNumber, and ItemPointerGetOffsetNumber.

Referenced by lazy_tid_reaped().

{
    BlockNumber lblk,
                rblk;
    OffsetNumber loff,
                roff;

    lblk = ItemPointerGetBlockNumber((ItemPointer) left);
    rblk = ItemPointerGetBlockNumber((ItemPointer) right);

    if (lblk < rblk)
        return -1;
    if (lblk > rblk)
        return 1;

    loff = ItemPointerGetOffsetNumber((ItemPointer) left);
    roff = ItemPointerGetOffsetNumber((ItemPointer) right);

    if (loff < roff)
        return -1;
    if (loff > roff)
        return 1;

    return 0;
}

vacuum_indexes_leader()

static void vacuum_indexes_leader ( Relation *  Irel, IndexBulkDeleteResult **  stats, LVRelStats *  vacrelstats, LVParallelState *  lps, int  nindexes  )

static

Definition at line 2159 of file vacuumlazy.c.

References Assert, LVRelStats::dead_tuples, get_indstats(), i, IsParallelWorker, LVParallelState::lvshared, pg_atomic_add_fetch_u32(), pg_atomic_sub_fetch_u32(), skip_parallel_vacuum_index(), vacuum_one_index(), and VacuumActiveNWorkers.

Referenced by lazy_parallel_vacuum_indexes().

{
    int         i;

    Assert(!IsParallelWorker());

    /*
     * Increment the active worker count if we are able to launch any worker.
     */
    if (VacuumActiveNWorkers)
        pg_atomic_add_fetch_u32(VacuumActiveNWorkers, 1);

    for (i = 0; i < nindexes; i++)
    {
        LVSharedIndStats *shared_indstats;

        shared_indstats = get_indstats(lps->lvshared, i);

        /* Process the indexes skipped by parallel workers */
        if (shared_indstats == NULL ||
            skip_parallel_vacuum_index(Irel[i], lps->lvshared))
            vacuum_one_index(Irel[i], &(stats[i]), lps->lvshared,
                             shared_indstats, vacrelstats->dead_tuples);
    }

    /*
     * We have completed the index vacuum so decrement the active worker
     * count.
     */
    if (VacuumActiveNWorkers)
        pg_atomic_sub_fetch_u32(VacuumActiveNWorkers, 1);
}

vacuum_log_cleanup_info()

static void vacuum_log_cleanup_info ( Relation  rel, LVRelStats *  vacrelstats  )

static

Definition at line 649 of file vacuumlazy.c.

References LVRelStats::latestRemovedXid, log_heap_cleanup_info(), RelationData::rd_node, RelationNeedsWAL, TransactionIdIsValid, and XLogIsNeeded.

Referenced by lazy_vacuum_all_indexes().

{
    /*
     * Skip this for relations for which no WAL is to be written, or if we're
     * not trying to support archive recovery.
     */
    if (!RelationNeedsWAL(rel) || !XLogIsNeeded())
        return;

    /*
     * No need to write the record at all unless it contains a valid value
     */
    if (TransactionIdIsValid(vacrelstats->latestRemovedXid))
        (void) log_heap_cleanup_info(rel->rd_node, vacrelstats->latestRemovedXid);
}

vacuum_one_index()

static void vacuum_one_index ( Relation  indrel, IndexBulkDeleteResult **  stats, LVShared *  lvshared, LVSharedIndStats *  shared_indstats, LVDeadTuples *  dead_tuples  )

static

Definition at line 2201 of file vacuumlazy.c.

References LVShared::estimated_count, LVShared::for_cleanup, lazy_cleanup_index(), lazy_vacuum_index(), pfree(), LVShared::reltuples, LVSharedIndStats::stats, and LVSharedIndStats::updated.

Referenced by parallel_vacuum_index(), and vacuum_indexes_leader().

{
    IndexBulkDeleteResult *bulkdelete_res = NULL;

    if (shared_indstats)
    {
        /* Get the space for IndexBulkDeleteResult */
        bulkdelete_res = &(shared_indstats->stats);

        /*
         * Update the pointer to the corresponding bulk-deletion result if
         * someone has already updated it.
         */
        if (shared_indstats->updated && *stats == NULL)
            *stats = bulkdelete_res;
    }

    /* Do vacuum or cleanup of the index */
    if (lvshared->for_cleanup)
        lazy_cleanup_index(indrel, stats, lvshared->reltuples,
                           lvshared->estimated_count);
    else
        lazy_vacuum_index(indrel, stats, dead_tuples,
                          lvshared->reltuples);

    /*
     * Copy the index bulk-deletion result returned from ambulkdelete and
     * amvacuumcleanup to the DSM segment if it's the first time to get it
     * from them, because they allocate it locally and it's possible that an
     * index will be vacuumed by the different vacuum process at the next
     * time.  The copying of the result normally happens only after the first
     * time of index vacuuming.  From the second time, we pass the result on
     * the DSM segment so that they then update it directly.
     *
     * Since all vacuum workers write the bulk-deletion result at different
     * slots we can write them without locking.
     */
    if (shared_indstats && !shared_indstats->updated && *stats != NULL)
    {
        memcpy(bulkdelete_res, *stats, sizeof(IndexBulkDeleteResult));
        shared_indstats->updated = true;

        /*
         * Now that the stats[idx] points to the DSM segment, we don't need
         * the locally allocated results.
         */
        pfree(*stats);
        *stats = bulkdelete_res;
    }
}

Variable Documentation

elevel

int elevel = -1

static

Definition at line 297 of file vacuumlazy.c.

Referenced by _ShowOption(), acquire_inherited_sample_rows(), analyze_rel(), begin_parallel_vacuum(), copy_table_data(), count_nondeletable_pages(), data_sync_elevel(), do_analyze_rel(), dsm_impl_op(), dsm_impl_sysv(), errfinish(), errstart(), heap_vacuum_rel(), lazy_cleanup_index(), lazy_parallel_vacuum_indexes(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_heap(), lazy_vacuum_index(), parallel_vacuum_main(), pg_flush_data(), RangeVarGetRelidExtended(), RestoreArchivedFile(), set_config_sourcefile(), vacuum_open_relation(), and walkdir().

FreezeLimit

TransactionId FreezeLimit

static

Definition at line 300 of file vacuumlazy.c.

Referenced by heap_vacuum_rel(), lazy_check_needs_freeze(), and lazy_scan_heap().

MultiXactCutoff

MultiXactId MultiXactCutoff

static

Definition at line 301 of file vacuumlazy.c.

Referenced by copy_table_data(), heap_vacuum_rel(), lazy_check_needs_freeze(), and lazy_scan_heap().

OldestXmin

TransactionId OldestXmin

static

Definition at line 299 of file vacuumlazy.c.

Referenced by acquire_sample_rows(), collect_corrupt_items(), copy_table_data(), heap_page_is_all_visible(), heap_page_prune_opt(), heap_vacuum_rel(), heapam_index_build_range_scan(), lazy_scan_heap(), and statapprox_heap().

vac_strategy

BufferAccessStrategy vac_strategy

static

Definition at line 303 of file vacuumlazy.c.

Referenced by lazy_cleanup_index(), and lazy_vacuum_index().