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 "executor/instrument.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
struct	LVSavedErrInfo

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	PARALLEL_VACUUM_KEY_BUFFER_USAGE   4
#define	PARALLEL_VACUUM_KEY_WAL_USAGE   5
#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
typedef struct LVSavedErrInfo	LVSavedErrInfo

Enumerations
enum	VacErrPhase {   VACUUM_ERRCB_PHASE_UNKNOWN, VACUUM_ERRCB_PHASE_SCAN_HEAP, VACUUM_ERRCB_PHASE_VACUUM_INDEX, VACUUM_ERRCB_PHASE_VACUUM_HEAP,   VACUUM_ERRCB_PHASE_INDEX_CLEANUP, VACUUM_ERRCB_PHASE_TRUNCATE }

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, LVRelStats *vacrelstats)
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, LVRelStats *vacrelstats)
static void	lazy_cleanup_index (Relation indrel, IndexBulkDeleteResult **stats, double reltuples, bool estimated_count, LVRelStats *vacrelstats)
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, LVRelStats *vacrelstats, 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, LVRelStats *vacrelstats)
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, LVRelStats *vacrelstats)
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 (IndexBulkDeleteResult **stats, LVParallelState *lps, int nindexes)
static LVSharedIndStats *	get_indstats (LVShared *lvshared, int n)
static bool	skip_parallel_vacuum_index (Relation indrel, LVShared *lvshared)
static void	vacuum_error_callback (void *arg)
static void	update_vacuum_error_info (LVRelStats *errinfo, LVSavedErrInfo *saved_err_info, int phase, BlockNumber blkno, OffsetNumber offnum)
static void	restore_vacuum_error_info (LVRelStats *errinfo, const LVSavedErrInfo *saved_err_info)
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 254 of file vacuumlazy.c.

Referenced by get_indstats().

IndStatsIsNull

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

Definition at line 256 of file vacuumlazy.c.

Referenced by get_indstats().

LAZY_ALLOC_TUPLES

#define LAZY_ALLOC_TUPLES   MaxHeapTuplesPerPage

Definition at line 119 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 180 of file vacuumlazy.c.

Referenced by compute_max_dead_tuples().

PARALLEL_VACUUM_KEY_BUFFER_USAGE

#define PARALLEL_VACUUM_KEY_BUFFER_USAGE   4

Definition at line 141 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and parallel_vacuum_main().

PARALLEL_VACUUM_KEY_DEAD_TUPLES

#define PARALLEL_VACUUM_KEY_DEAD_TUPLES   2

Definition at line 139 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 140 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 138 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and parallel_vacuum_main().

PARALLEL_VACUUM_KEY_WAL_USAGE

#define PARALLEL_VACUUM_KEY_WAL_USAGE   5

Definition at line 142 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and parallel_vacuum_main().

ParallelVacuumIsActive

#define ParallelVacuumIsActive

(

lps

)

PointerIsValid(lps)

Definition at line 148 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 131 of file vacuumlazy.c.

Referenced by count_nondeletable_pages().

REL_TRUNCATE_FRACTION

#define REL_TRUNCATE_FRACTION   16

Definition at line 92 of file vacuumlazy.c.

Referenced by should_attempt_truncation().

REL_TRUNCATE_MINIMUM

#define REL_TRUNCATE_MINIMUM   1000

Definition at line 91 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 177 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum(), and lazy_space_alloc().

SizeOfLVShared

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

Definition at line 253 of file vacuumlazy.c.

Referenced by begin_parallel_vacuum().

SKIP_PAGES_THRESHOLD

#define SKIP_PAGES_THRESHOLD   ((BlockNumber) 32)

Definition at line 125 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 111 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 101 of file vacuumlazy.c.

Referenced by count_nondeletable_pages().

VACUUM_TRUNCATE_LOCK_TIMEOUT

#define VACUUM_TRUNCATE_LOCK_TIMEOUT   5000 /* ms */

Definition at line 103 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 102 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

LVSavedErrInfo

typedef struct LVSavedErrInfo LVSavedErrInfo

LVShared

typedef struct LVShared LVShared

LVSharedIndStats

typedef struct LVSharedIndStats LVSharedIndStats

Enumeration Type Documentation

VacErrPhase

enum VacErrPhase

Enumerator
VACUUM_ERRCB_PHASE_UNKNOWN
VACUUM_ERRCB_PHASE_SCAN_HEAP
VACUUM_ERRCB_PHASE_VACUUM_INDEX
VACUUM_ERRCB_PHASE_VACUUM_HEAP
VACUUM_ERRCB_PHASE_INDEX_CLEANUP
VACUUM_ERRCB_PHASE_TRUNCATE

Definition at line 151 of file vacuumlazy.c.

{
    VACUUM_ERRCB_PHASE_UNKNOWN,
    VACUUM_ERRCB_PHASE_SCAN_HEAP,
    VACUUM_ERRCB_PHASE_VACUUM_INDEX,
    VACUUM_ERRCB_PHASE_VACUUM_HEAP,
    VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
    VACUUM_ERRCB_PHASE_TRUNCATE
} VacErrPhase;

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 3217 of file vacuumlazy.c.

References LVShared::active_nworkers, add_size(), IndexAmRoutine::amparallelvacuumoptions, Assert, BITMAPLEN, LVParallelState::buffer_usage, 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, mul_size(), LVParallelState::nindexes_parallel_bulkdel, LVParallelState::nindexes_parallel_cleanup, LVParallelState::nindexes_parallel_condcleanup, LVDeadTuples::num_tuples, ParallelContext::nworkers, LVShared::offset, palloc0(), PARALLEL_VACUUM_KEY_BUFFER_USAGE, PARALLEL_VACUUM_KEY_DEAD_TUPLES, PARALLEL_VACUUM_KEY_QUERY_TEXT, PARALLEL_VACUUM_KEY_SHARED, PARALLEL_VACUUM_KEY_WAL_USAGE, 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, VACUUM_OPTION_PARALLEL_COND_CLEANUP, and LVParallelState::wal_usage.

Referenced by lazy_scan_heap().

{
    LVParallelState *lps = NULL;
    ParallelContext *pcxt;
    LVShared   *shared;
    LVDeadTuples *dead_tuples;
    BufferUsage *buffer_usage;
    WalUsage   *wal_usage;
    bool       *can_parallel_vacuum;
    long        maxtuples;
    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);

    /*
     * Estimate space for BufferUsage and WalUsage --
     * PARALLEL_VACUUM_KEY_BUFFER_USAGE and PARALLEL_VACUUM_KEY_WAL_USAGE.
     *
     * If there are no extensions loaded that care, we could skip this.  We
     * have no way of knowing whether anyone's looking at pgBufferUsage or
     * pgWalUsage, so do it unconditionally.
     */
    shm_toc_estimate_chunk(&pcxt->estimator,
                           mul_size(sizeof(BufferUsage), pcxt->nworkers));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
    shm_toc_estimate_chunk(&pcxt->estimator,
                           mul_size(sizeof(WalUsage), pcxt->nworkers));
    shm_toc_estimate_keys(&pcxt->estimator, 1);

    /* Finally, estimate PARALLEL_VACUUM_KEY_QUERY_TEXT space */
    if (debug_query_string)
    {
        querylen = strlen(debug_query_string);
        shm_toc_estimate_chunk(&pcxt->estimator, querylen + 1);
        shm_toc_estimate_keys(&pcxt->estimator, 1);
    }
    else
        querylen = 0;           /* keep compiler quiet */

    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;

    /*
     * Allocate space for each worker's BufferUsage and WalUsage; no need to
     * initialize
     */
    buffer_usage = shm_toc_allocate(pcxt->toc,
                                    mul_size(sizeof(BufferUsage), pcxt->nworkers));
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_BUFFER_USAGE, buffer_usage);
    lps->buffer_usage = buffer_usage;
    wal_usage = shm_toc_allocate(pcxt->toc,
                                 mul_size(sizeof(WalUsage), pcxt->nworkers));
    shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_WAL_USAGE, wal_usage);
    lps->wal_usage = wal_usage;

    /* Store query string for workers */
    if (debug_query_string)
    {
        char       *sharedquery;

        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 2847 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 3100 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 performing 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 2708 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, LVRelStats::relname, 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",
                                    vacrelstats->relname)));

                    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 ( IndexBulkDeleteResult **  stats, LVParallelState *  lps, int  nindexes  )

static

Definition at line 3401 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 3439 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, LVRelStats *  vacrelstats, TransactionId *  visibility_cutoff_xid, bool *  all_frozen  )

static

Definition at line 2972 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(), InvalidOffsetNumber, InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet, LVRelStats::offnum, 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;

        /*
         * Set the offset number so that we can display it along with any
         * error that occurred while processing this tuple.
         */
        vacrelstats->offnum = offnum;
        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 */

    /* Clear the offset information once we have processed the given page. */
    vacrelstats->offnum = InvalidOffsetNumber;

    return all_visible;
}

heap_vacuum_rel()

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

Definition at line 419 of file vacuumlazy.c.

References _, appendStringInfo(), ErrorContextCallback::arg, Assert, buf, ErrorContextCallback::callback, StringInfoData::data, DEBUG2, elevel, ereport, errmsg_internal(), error_context_stack, VacuumParams::freeze_min_age, VacuumParams::freeze_table_age, FreezeLimit, LVRelStats::frozenskipped_pages, get_database_name(), get_namespace_name(), GetCurrentTimestamp(), VacuumParams::index_cleanup, LVRelStats::indname, INFO, initStringInfo(), InvalidMultiXactId, InvalidOffsetNumber, InvalidTransactionId, VacuumParams::is_wraparound, IsAutoVacuumWorkerProcess(), lazy_scan_heap(), lazy_truncate_heap(), LVRelStats::lock_waiter_detected, LOG, VacuumParams::log_min_duration, Max, 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::nonempty_pages, 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(), pgWalUsage, LVRelStats::phase, LVRelStats::pinskipped_pages, ErrorContextCallback::previous, PROGRESS_COMMAND_VACUUM, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_FINAL_CLEANUP, pstrdup(), RelationData::rd_rel, LVRelStats::rel_pages, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, LVRelStats::relname, LVRelStats::relnamespace, RowExclusiveLock, LVRelStats::scanned_pages, should_attempt_truncation(), TimestampDifference(), TimestampDifferenceExceeds(), TransactionIdIsNormal, TransactionIdPrecedesOrEquals(), VacuumParams::truncate, LVRelStats::tuples_deleted, update_vacuum_error_info(), LVRelStats::useindex, vac_close_indexes(), vac_open_indexes(), vac_update_relstats(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_TERNARY_DEFAULT, VACOPT_TERNARY_ENABLED, VACOPT_VERBOSE, VACUUM_ERRCB_PHASE_TRUNCATE, VACUUM_ERRCB_PHASE_UNKNOWN, vacuum_error_callback(), vacuum_set_xid_limits(), VacuumPageDirty, VacuumPageHit, VacuumPageMiss, visibilitymap_count(), WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_records, and WalUsageAccumDiff().

Referenced by SampleHeapTupleVisible().

{
    LVRelStats *vacrelstats;
    Relation   *Irel;
    int         nindexes;
    PGRUsage    ru0;
    TimestampTz starttime = 0;
    WalUsage    walusage_start = pgWalUsage;
    WalUsage    walusage = {0, 0, 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;
    ErrorContextCallback errcallback;

    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;

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

    vacrelstats->relnamespace = get_namespace_name(RelationGetNamespace(onerel));
    vacrelstats->relname = pstrdup(RelationGetRelationName(onerel));
    vacrelstats->indname = NULL;
    vacrelstats->phase = VACUUM_ERRCB_PHASE_UNKNOWN;
    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);

    /*
     * Setup error traceback support for ereport().  The idea is to set up an
     * error context callback to display additional information on any error
     * during a vacuum.  During different phases of vacuum (heap scan, heap
     * vacuum, index vacuum, index clean up, heap truncate), we update the
     * error context callback to display appropriate information.
     *
     * Note that the index vacuum and heap vacuum phases may be called
     * multiple times in the middle of the heap scan phase.  So the old phase
     * information is restored at the end of those phases.
     */
    errcallback.callback = vacuum_error_callback;
    errcallback.arg = vacrelstats;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;

    /* 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))
    {
        /*
         * Update error traceback information.  This is the last phase during
         * which we add context information to errors, so we don't need to
         * revert to the previous phase.
         */
        update_vacuum_error_info(vacrelstats, NULL, VACUUM_ERRCB_PHASE_TRUNCATE,
                                 vacrelstats->nonempty_pages,
                                 InvalidOffsetNumber);
        lazy_truncate_heap(onerel, vacrelstats);
    }

    /* Pop the error context stack */
    error_context_stack = errcallback.previous;

    /* 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.
     *
     * In principle new_live_tuples could be -1 indicating that we (still)
     * don't know the tuple count.  In practice that probably can't happen,
     * since we'd surely have scanned some pages if the table is new and
     * nonempty.
     *
     * For safety, clamp relallvisible 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;

    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,
                         Max(new_live_tuples, 0),
                         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);

            memset(&walusage, 0, sizeof(WalUsage));
            WalUsageAccumDiff(&walusage, &pgWalUsage, &walusage_start);

            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)
            {
                if (aggressive)
                    msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
                else
                    msgfmt = _("automatic 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),
                             vacrelstats->relnamespace,
                             vacrelstats->relname,
                             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\n"), pg_rusage_show(&ru0));
            appendStringInfo(&buf,
                             _("WAL usage: %ld records, %ld full page images, %llu bytes"),
                             walusage.wal_records,
                             walusage.wal_fpi,
                             (unsigned long long) walusage.wal_bytes);

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

lazy_check_needs_freeze()

static bool lazy_check_needs_freeze ( Buffer  buf, bool *  hastup, LVRelStats *  vacrelstats  )

static

Definition at line 2031 of file vacuumlazy.c.

References BufferGetPage, FirstOffsetNumber, FreezeLimit, heap_tuple_needs_freeze(), InvalidOffsetNumber, ItemIdIsNormal, ItemIdIsUsed, MultiXactCutoff, LVRelStats::offnum, 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;

        /*
         * Set the offset number so that we can display it along with any
         * error that occurred while processing this tuple.
         */
        vacrelstats->offnum = offnum;
        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))
            break;
    }                           /* scan along page */

    /* Clear the offset information once we have processed the given page. */
    vacrelstats->offnum = InvalidOffsetNumber;

    return (offnum <= maxoff);
}

lazy_cleanup_all_indexes()

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

static

Definition at line 2376 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,
                               vacrelstats);
    }
}

lazy_cleanup_index()

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

static

Definition at line 2483 of file vacuumlazy.c.

References IndexVacuumInfo::analyze_only, Assert, elevel, ereport, errdetail(), errmsg(), IndexVacuumInfo::estimated_count, IndexVacuumInfo::index, index_vacuum_cleanup(), LVRelStats::indname, InvalidBlockNumber, InvalidOffsetNumber, IndexVacuumInfo::message_level, IndexVacuumInfo::num_heap_tuples, pfree(), pg_rusage_init(), pg_rusage_show(), pstrdup(), RelationGetRelationName, IndexVacuumInfo::report_progress, restore_vacuum_error_info(), IndexVacuumInfo::strategy, update_vacuum_error_info(), vac_strategy, and VACUUM_ERRCB_PHASE_INDEX_CLEANUP.

Referenced by lazy_cleanup_all_indexes(), and vacuum_one_index().

{
    IndexVacuumInfo ivinfo;
    PGRUsage    ru0;
    LVSavedErrInfo saved_err_info;

    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;

    /*
     * Update error traceback information.
     *
     * The index name is saved during this phase and restored immediately
     * after this phase.  See vacuum_error_callback.
     */
    Assert(vacrelstats->indname == NULL);
    vacrelstats->indname = pstrdup(RelationGetRelationName(indrel));
    update_vacuum_error_info(vacrelstats, &saved_err_info,
                             VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
                             InvalidBlockNumber, InvalidOffsetNumber);

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

    if (*stats)
    {
        ereport(elevel,
                (errmsg("index \"%s\" now contains %.0f row versions in %u pages",
                        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))));
    }

    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrelstats, &saved_err_info);
    pfree(vacrelstats->indname);
    vacrelstats->indname = NULL;
}

lazy_parallel_vacuum_indexes()

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

static

Definition at line 2091 of file vacuumlazy.c.

References LVShared::active_nworkers, Assert, LVParallelState::buffer_usage, LVShared::cost_balance, LVRelStats::dead_tuples, elevel, ereport, errmsg(), LVShared::first_time, LVShared::for_cleanup, i, LVShared::idx, InstrAccumParallelQuery(), 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, WaitForParallelWorkersToFinish(), and LVParallelState::wal_usage.

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, vacrelstats);

    /*
     * Next, accumulate buffer and WAL usage.  (This must wait for the workers
     * to finish, or we might get incomplete data.)
     */
    if (nworkers > 0)
    {
        int         i;

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

        for (i = 0; i < lps->pcxt->nworkers_launched; i++)
            InstrAccumParallelQuery(&lps->buffer_usage[i], &lps->wal_usage[i]);
    }

    /*
     * 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 2897 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 753 of file vacuumlazy.c.

References _, appendStringInfo(), Assert, begin_parallel_vacuum(), LVRelStats::blkno, 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, GetRecordedFreeSpace(), GlobalVisTestFor(), 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(), InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, 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(), Max, 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, LVRelStats::offnum, 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, RelationGetNumberOfBlocks, RelationGetRelid, RelationNeedsWAL, RelationUsesLocalBuffers, ReleaseBuffer(), LVRelStats::relname, LVRelStats::relnamespace, 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(), update_vacuum_error_info(), LVRelStats::useindex, vac_estimate_reltuples(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_TERNARY_DISABLED, vacuum_delay_point(), VACUUM_ERRCB_PHASE_SCAN_HEAP, 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;
    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];
    GlobalVisState *vistest;

    pg_rusage_init(&ru0);

    if (aggressive)
        ereport(elevel,
                (errmsg("aggressively vacuuming \"%s.%s\"",
                        vacrelstats->relnamespace,
                        vacrelstats->relname)));
    else
        ereport(elevel,
                (errmsg("vacuuming \"%s.%s\"",
                        vacrelstats->relnamespace,
                        vacrelstats->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;

    vistest = GlobalVisTestFor(onerel);

    /*
     * Initialize 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",
                                vacrelstats->relname)));
        }
        else
            lps = begin_parallel_vacuum(RelationGetRelid(onerel), Irel,
                                        vacrelstats, nblocks, nindexes,
                                        params->nworkers);
    }

    /*
     * Allocate the space for dead tuples in case 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);

        update_vacuum_error_info(vacrelstats, NULL, VACUUM_ERRCB_PHASE_SCAN_HEAP,
                                 blkno, InvalidOffsetNumber);

        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, vacrelstats))
            {
                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))
        {
            /*
             * 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).
             *
             * 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.
             *
             * 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. We do so after releasing the lock
             * on the heap page, the FSM is approximate, after all.
             */
            UnlockReleaseBuffer(buf);

            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, vistest, false,
                                         InvalidTransactionId, 0,
                                         &vacrelstats->latestRemovedXid,
                                         &vacrelstats->offnum);

        /*
         * 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;

            /*
             * Set the offset number so that we can display it along with any
             * error that occurred while processing this tuple.
             */
            vacrelstats->offnum = offnum;
            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 */

        /*
         * Clear the offset information once we have processed all the tuples
         * on the page.
         */
        vacrelstats->offnum = InvalidOffsetNumber;

        /*
         * 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",
                 vacrelstats->relname, blkno);
            visibilitymap_clear(onerel, blkno, vmbuffer,
                                VISIBILITYMAP_VALID_BITS);
        }

        /*
         * It's possible for the value returned by
         * GetOldestNonRemovableTransactionId() 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
         * GetOldestNonRemovableTransactionId() 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",
                 vacrelstats->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);

    /* Clear the block number information */
    vacrelstats->blkno = InvalidBlockNumber;

    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 the total number of surviving heap entries.  In the
     * (unlikely) scenario that new_live_tuples is -1, take it as zero.
     */
    vacrelstats->new_rel_tuples =
        Max(vacrelstats->new_live_tuples, 0) + 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(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",
                        vacrelstats->relname,
                        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",
                    vacrelstats->relname,
                    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 2879 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 2921 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 2578 of file vacuumlazy.c.

References AccessExclusiveLock, LVRelStats::blkno, 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, RelationTruncate(), LVRelStats::relname, 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",
                                vacrelstats->relname)));
                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);
        vacrelstats->blkno = new_rel_pages;

        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",
                        vacrelstats->relname,
                        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 1784 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, vacrelstats);
    }

    /* 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 1843 of file vacuumlazy.c.

References LVRelStats::blkno, buf, BufferGetPage, BufferIsValid, ConditionalLockBufferForCleanup(), LVRelStats::dead_tuples, elevel, ereport, errdetail_internal(), errmsg(), InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, 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(), ReleaseBuffer(), LVRelStats::relname, restore_vacuum_error_info(), UnlockReleaseBuffer(), update_vacuum_error_info(), vacuum_delay_point(), and VACUUM_ERRCB_PHASE_VACUUM_HEAP.

Referenced by lazy_scan_heap().

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

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

    /* Update error traceback information */
    update_vacuum_error_info(vacrelstats, &saved_err_info, VACUUM_ERRCB_PHASE_VACUUM_HEAP,
                             InvalidBlockNumber, InvalidOffsetNumber);

    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]);
        vacrelstats->blkno = tblk;
        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++;
    }

    /* Clear the block number information */
    vacrelstats->blkno = InvalidBlockNumber;

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

    ereport(elevel,
            (errmsg("\"%s\": removed %d row versions in %d pages",
                    vacrelstats->relname,
                    tupindex, npages),
             errdetail_internal("%s", pg_rusage_show(&ru0))));

    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrelstats, &saved_err_info);
}

lazy_vacuum_index()

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

static

Definition at line 2431 of file vacuumlazy.c.

References IndexVacuumInfo::analyze_only, Assert, elevel, ereport, errdetail_internal(), errmsg(), IndexVacuumInfo::estimated_count, IndexVacuumInfo::index, index_bulk_delete(), LVRelStats::indname, InvalidBlockNumber, InvalidOffsetNumber, lazy_tid_reaped(), IndexVacuumInfo::message_level, IndexVacuumInfo::num_heap_tuples, pfree(), pg_rusage_init(), pg_rusage_show(), pstrdup(), RelationGetRelationName, IndexVacuumInfo::report_progress, restore_vacuum_error_info(), IndexVacuumInfo::strategy, update_vacuum_error_info(), vac_strategy, and VACUUM_ERRCB_PHASE_VACUUM_INDEX.

Referenced by lazy_vacuum_all_indexes(), and vacuum_one_index().

{
    IndexVacuumInfo ivinfo;
    PGRUsage    ru0;
    LVSavedErrInfo saved_err_info;

    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;

    /*
     * Update error traceback information.
     *
     * The index name is saved during this phase and restored immediately
     * after this phase.  See vacuum_error_callback.
     */
    Assert(vacrelstats->indname == NULL);
    vacrelstats->indname = pstrdup(RelationGetRelationName(indrel));
    update_vacuum_error_info(vacrelstats, &saved_err_info,
                             VACUUM_ERRCB_PHASE_VACUUM_INDEX,
                             InvalidBlockNumber, InvalidOffsetNumber);

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

    ereport(elevel,
            (errmsg("scanned index \"%s\" to remove %d row versions",
                    vacrelstats->indname,
                    dead_tuples->num_tuples),
             errdetail_internal("%s", pg_rusage_show(&ru0))));

    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrelstats, &saved_err_info);
    pfree(vacrelstats->indname);
    vacrelstats->indname = NULL;
}

lazy_vacuum_page()

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

static

Definition at line 1924 of file vacuumlazy.c.

References Assert, BufferGetPage, BufferIsValid, LVRelStats::dead_tuples, END_CRIT_SECTION, heap_page_is_all_visible(), InvalidOffsetNumber, 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, restore_vacuum_error_info(), START_CRIT_SECTION, update_vacuum_error_info(), VACUUM_ERRCB_PHASE_VACUUM_HEAP, 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;
    LVSavedErrInfo saved_err_info;

    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, blkno);

    /* Update error traceback information */
    update_vacuum_error_info(vacrelstats, &saved_err_info, VACUUM_ERRCB_PHASE_VACUUM_HEAP,
                             blkno, InvalidOffsetNumber);

    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, vacrelstats,
                                 &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);
    }

    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrelstats, &saved_err_info);
    return tupindex;
}

parallel_vacuum_index()

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

static

Definition at line 2221 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 don'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, vacrelstats);
    }

    /*
     * 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 3504 of file vacuumlazy.c.

References LVShared::active_nworkers, ErrorContextCallback::arg, Assert, ErrorContextCallback::callback, LVShared::cost_balance, DEBUG1, debug_query_string, LVShared::elevel, elevel, elog, error_context_stack, LVShared::for_cleanup, get_namespace_name(), LVRelStats::indname, InstrEndParallelQuery(), InstrStartParallelQuery(), maintenance_work_mem, LVShared::maintenance_work_mem_worker, palloc0(), parallel_vacuum_index(), PARALLEL_VACUUM_KEY_BUFFER_USAGE, PARALLEL_VACUUM_KEY_DEAD_TUPLES, PARALLEL_VACUUM_KEY_QUERY_TEXT, PARALLEL_VACUUM_KEY_SHARED, PARALLEL_VACUUM_KEY_WAL_USAGE, ParallelWorkerNumber, pfree(), pgstat_report_activity(), LVRelStats::phase, ErrorContextCallback::previous, pstrdup(), RelationGetNamespace, RelationGetRelationName, LVShared::relid, LVRelStats::relname, LVRelStats::relnamespace, RowExclusiveLock, ShareUpdateExclusiveLock, shm_toc_lookup(), STATE_RUNNING, table_close(), table_open(), vac_close_indexes(), vac_open_indexes(), VACUUM_ERRCB_PHASE_UNKNOWN, vacuum_error_callback(), VacuumActiveNWorkers, VacuumCostActive, VacuumCostBalance, VacuumCostBalanceLocal, VacuumCostDelay, VacuumPageDirty, VacuumPageHit, VacuumPageMiss, and VacuumSharedCostBalance.

{
    Relation    onerel;
    Relation   *indrels;
    LVShared   *lvshared;
    LVDeadTuples *dead_tuples;
    BufferUsage *buffer_usage;
    WalUsage   *wal_usage;
    int         nindexes;
    char       *sharedquery;
    IndexBulkDeleteResult **stats;
    LVRelStats  vacrelstats;
    ErrorContextCallback errcallback;

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

    if (lvshared->for_cleanup)
        elog(DEBUG1, "starting parallel vacuum worker for cleanup");
    else
        elog(DEBUG1, "starting parallel vacuum worker for bulk delete");

    /* Set debug_query_string for individual workers */
    sharedquery = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_QUERY_TEXT, true);
    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;

    /*
     * Initialize vacrelstats for use as error callback arg by parallel
     * worker.
     */
    vacrelstats.relnamespace = get_namespace_name(RelationGetNamespace(onerel));
    vacrelstats.relname = pstrdup(RelationGetRelationName(onerel));
    vacrelstats.indname = NULL;
    vacrelstats.phase = VACUUM_ERRCB_PHASE_UNKNOWN; /* Not yet processing */

    /* Setup error traceback support for ereport() */
    errcallback.callback = vacuum_error_callback;
    errcallback.arg = &vacrelstats;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;

    /* Prepare to track buffer usage during parallel execution */
    InstrStartParallelQuery();

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

    /* Report buffer/WAL usage during parallel execution */
    buffer_usage = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_BUFFER_USAGE, false);
    wal_usage = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_WAL_USAGE, false);
    InstrEndParallelQuery(&buffer_usage[ParallelWorkerNumber],
                          &wal_usage[ParallelWorkerNumber]);

    /* Pop the error context stack */
    error_context_stack = errcallback.previous;

    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 3161 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 does support parallelism */
        lvshared->bitmap[i >> 3] |= 1 << (i & 0x07);
    }
}

restore_vacuum_error_info()

static void restore_vacuum_error_info ( LVRelStats *  errinfo, const LVSavedErrInfo *  saved_err_info  )

static

Definition at line 3690 of file vacuumlazy.c.

References LVRelStats::blkno, LVSavedErrInfo::blkno, LVRelStats::offnum, LVSavedErrInfo::offnum, LVRelStats::phase, and LVSavedErrInfo::phase.

Referenced by lazy_cleanup_index(), lazy_vacuum_heap(), lazy_vacuum_index(), and lazy_vacuum_page().

{
    errinfo->blkno = saved_err_info->blkno;
    errinfo->offnum = saved_err_info->offnum;
    errinfo->phase = saved_err_info->phase;
}

should_attempt_truncation()

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

static

Definition at line 2557 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 3464 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 3186 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]);
    }
}

update_vacuum_error_info()

static void update_vacuum_error_info ( LVRelStats *  errinfo, LVSavedErrInfo *  saved_err_info, int  phase, BlockNumber  blkno, OffsetNumber  offnum  )

static

Definition at line 3671 of file vacuumlazy.c.

References LVRelStats::blkno, LVSavedErrInfo::blkno, LVRelStats::offnum, LVSavedErrInfo::offnum, LVRelStats::phase, and LVSavedErrInfo::phase.

Referenced by heap_vacuum_rel(), lazy_cleanup_index(), lazy_scan_heap(), lazy_vacuum_heap(), lazy_vacuum_index(), and lazy_vacuum_page().

{
    if (saved_err_info)
    {
        saved_err_info->offnum = errinfo->offnum;
        saved_err_info->blkno = errinfo->blkno;
        saved_err_info->phase = errinfo->phase;
    }

    errinfo->blkno = blkno;
    errinfo->offnum = offnum;
    errinfo->phase = phase;
}

vac_cmp_itemptr()

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

static

Definition at line 2939 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_error_callback()

static void vacuum_error_callback ( void *  arg )

static

Definition at line 3607 of file vacuumlazy.c.

References arg, LVRelStats::blkno, BlockNumberIsValid, errcontext, LVRelStats::indname, LVRelStats::offnum, OffsetNumberIsValid, LVRelStats::phase, LVRelStats::relname, LVRelStats::relnamespace, VACUUM_ERRCB_PHASE_INDEX_CLEANUP, VACUUM_ERRCB_PHASE_SCAN_HEAP, VACUUM_ERRCB_PHASE_TRUNCATE, VACUUM_ERRCB_PHASE_UNKNOWN, VACUUM_ERRCB_PHASE_VACUUM_HEAP, and VACUUM_ERRCB_PHASE_VACUUM_INDEX.

Referenced by heap_vacuum_rel(), and parallel_vacuum_main().

{
    LVRelStats *errinfo = arg;

    switch (errinfo->phase)
    {
        case VACUUM_ERRCB_PHASE_SCAN_HEAP:
            if (BlockNumberIsValid(errinfo->blkno))
            {
                if (OffsetNumberIsValid(errinfo->offnum))
                    errcontext("while scanning block %u and offset %u of relation \"%s.%s\"",
                               errinfo->blkno, errinfo->offnum, errinfo->relnamespace, errinfo->relname);
                else
                    errcontext("while scanning block %u of relation \"%s.%s\"",
                               errinfo->blkno, errinfo->relnamespace, errinfo->relname);
            }
            else
                errcontext("while scanning relation \"%s.%s\"",
                           errinfo->relnamespace, errinfo->relname);
            break;

        case VACUUM_ERRCB_PHASE_VACUUM_HEAP:
            if (BlockNumberIsValid(errinfo->blkno))
            {
                if (OffsetNumberIsValid(errinfo->offnum))
                    errcontext("while vacuuming block %u and offset %u of relation \"%s.%s\"",
                               errinfo->blkno, errinfo->offnum, errinfo->relnamespace, errinfo->relname);
                else
                    errcontext("while vacuuming block %u of relation \"%s.%s\"",
                               errinfo->blkno, errinfo->relnamespace, errinfo->relname);
            }
            else
                errcontext("while vacuuming relation \"%s.%s\"",
                           errinfo->relnamespace, errinfo->relname);
            break;

        case VACUUM_ERRCB_PHASE_VACUUM_INDEX:
            errcontext("while vacuuming index \"%s\" of relation \"%s.%s\"",
                       errinfo->indname, errinfo->relnamespace, errinfo->relname);
            break;

        case VACUUM_ERRCB_PHASE_INDEX_CLEANUP:
            errcontext("while cleaning up index \"%s\" of relation \"%s.%s\"",
                       errinfo->indname, errinfo->relnamespace, errinfo->relname);
            break;

        case VACUUM_ERRCB_PHASE_TRUNCATE:
            if (BlockNumberIsValid(errinfo->blkno))
                errcontext("while truncating relation \"%s.%s\" to %u blocks",
                           errinfo->relnamespace, errinfo->relname, errinfo->blkno);
            break;

        case VACUUM_ERRCB_PHASE_UNKNOWN:
        default:
            return;             /* do nothing; the errinfo may not be
                                 * initialized */
    }
}

vacuum_indexes_leader()

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

static

Definition at line 2273 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,
                             vacrelstats);
    }

    /*
     * 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 708 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, LVRelStats *  vacrelstats  )

static

Definition at line 2316 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)
    {