vacuumlazy.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/genam.h"
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/multixact.h"
#include "access/tidstore.h"
#include "access/transam.h"
#include "access/visibilitymap.h"
#include "access/xloginsert.h"
#include "catalog/storage.h"
#include "commands/progress.h"
#include "commands/vacuum.h"
#include "common/int.h"
#include "common/pg_prng.h"
#include "executor/instrument.h"
#include "miscadmin.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 "storage/read_stream.h"
#include "utils/lsyscache.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	LVRelState
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	BYPASS_THRESHOLD_PAGES   0.02 /* i.e. 2% of rel_pages */
#define	FAILSAFE_EVERY_PAGES    ((BlockNumber) (((uint64) 4 * 1024 * 1024 * 1024) / BLCKSZ))
#define	VACUUM_FSM_EVERY_PAGES    ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ))
#define	SKIP_PAGES_THRESHOLD   ((BlockNumber) 32)
#define	PREFETCH_SIZE   ((BlockNumber) 32)
#define	ParallelVacuumIsActive(vacrel)   ((vacrel)->pvs != NULL)
#define	MAX_EAGER_FREEZE_SUCCESS_RATE   0.2
#define	EAGER_SCAN_REGION_SIZE   4096
#define	VAC_BLK_WAS_EAGER_SCANNED   (1 << 0)
#define	VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM   (1 << 1)

Typedefs
typedef struct LVRelState	LVRelState
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 (LVRelState *vacrel)
static void	heap_vacuum_eager_scan_setup (LVRelState *vacrel, const VacuumParams params)
static BlockNumber	heap_vac_scan_next_block (ReadStream *stream, void *callback_private_data, void *per_buffer_data)
static void	find_next_unskippable_block (LVRelState *vacrel, bool *skipsallvis)
static bool	lazy_scan_new_or_empty (LVRelState *vacrel, Buffer buf, BlockNumber blkno, Page page, bool sharelock, Buffer vmbuffer)
static int	lazy_scan_prune (LVRelState *vacrel, Buffer buf, BlockNumber blkno, Page page, Buffer vmbuffer, bool all_visible_according_to_vm, bool *has_lpdead_items, bool *vm_page_frozen)
static bool	lazy_scan_noprune (LVRelState *vacrel, Buffer buf, BlockNumber blkno, Page page, bool *has_lpdead_items)
static void	lazy_vacuum (LVRelState *vacrel)
static bool	lazy_vacuum_all_indexes (LVRelState *vacrel)
static void	lazy_vacuum_heap_rel (LVRelState *vacrel)
static void	lazy_vacuum_heap_page (LVRelState *vacrel, BlockNumber blkno, Buffer buffer, OffsetNumber *deadoffsets, int num_offsets, Buffer vmbuffer)
static bool	lazy_check_wraparound_failsafe (LVRelState *vacrel)
static void	lazy_cleanup_all_indexes (LVRelState *vacrel)
static IndexBulkDeleteResult *	lazy_vacuum_one_index (Relation indrel, IndexBulkDeleteResult *istat, double reltuples, LVRelState *vacrel)
static IndexBulkDeleteResult *	lazy_cleanup_one_index (Relation indrel, IndexBulkDeleteResult *istat, double reltuples, bool estimated_count, LVRelState *vacrel)
static bool	should_attempt_truncation (LVRelState *vacrel)
static void	lazy_truncate_heap (LVRelState *vacrel)
static BlockNumber	count_nondeletable_pages (LVRelState *vacrel, bool *lock_waiter_detected)
static void	dead_items_alloc (LVRelState *vacrel, int nworkers)
static void	dead_items_add (LVRelState *vacrel, BlockNumber blkno, OffsetNumber *offsets, int num_offsets)
static void	dead_items_reset (LVRelState *vacrel)
static void	dead_items_cleanup (LVRelState *vacrel)
static bool	heap_page_would_be_all_visible (Relation rel, Buffer buf, TransactionId OldestXmin, OffsetNumber *deadoffsets, int ndeadoffsets, bool *all_frozen, TransactionId *visibility_cutoff_xid, OffsetNumber *logging_offnum)
static void	update_relstats_all_indexes (LVRelState *vacrel)
static void	vacuum_error_callback (void *arg)
static void	update_vacuum_error_info (LVRelState *vacrel, LVSavedErrInfo *saved_vacrel, int phase, BlockNumber blkno, OffsetNumber offnum)
static void	restore_vacuum_error_info (LVRelState *vacrel, const LVSavedErrInfo *saved_vacrel)
void	heap_vacuum_rel (Relation rel, const VacuumParams params, BufferAccessStrategy bstrategy)
static int	cmpOffsetNumbers (const void *a, const void *b)
static BlockNumber	vacuum_reap_lp_read_stream_next (ReadStream *stream, void *callback_private_data, void *per_buffer_data)

Macro Definition Documentation

BYPASS_THRESHOLD_PAGES

#define BYPASS_THRESHOLD_PAGES   0.02 /* i.e. 2% of rel_pages */

Definition at line 186 of file vacuumlazy.c.

EAGER_SCAN_REGION_SIZE

#define EAGER_SCAN_REGION_SIZE   4096

Definition at line 249 of file vacuumlazy.c.

FAILSAFE_EVERY_PAGES

#define FAILSAFE_EVERY_PAGES    ((BlockNumber) (((uint64) 4 * 1024 * 1024 * 1024) / BLCKSZ))

Definition at line 192 of file vacuumlazy.c.

MAX_EAGER_FREEZE_SUCCESS_RATE

#define MAX_EAGER_FREEZE_SUCCESS_RATE   0.2

Definition at line 240 of file vacuumlazy.c.

ParallelVacuumIsActive

#define ParallelVacuumIsActive

(

vacrel

)

((vacrel)->pvs != NULL)

Definition at line 220 of file vacuumlazy.c.

PREFETCH_SIZE

#define PREFETCH_SIZE   ((BlockNumber) 32)

Definition at line 214 of file vacuumlazy.c.

REL_TRUNCATE_FRACTION

#define REL_TRUNCATE_FRACTION   16

Definition at line 169 of file vacuumlazy.c.

REL_TRUNCATE_MINIMUM

#define REL_TRUNCATE_MINIMUM   1000

Definition at line 168 of file vacuumlazy.c.

SKIP_PAGES_THRESHOLD

#define SKIP_PAGES_THRESHOLD   ((BlockNumber) 32)

Definition at line 208 of file vacuumlazy.c.

VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM

#define VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM   (1 << 1)

Definition at line 256 of file vacuumlazy.c.

VAC_BLK_WAS_EAGER_SCANNED

#define VAC_BLK_WAS_EAGER_SCANNED   (1 << 0)

Definition at line 255 of file vacuumlazy.c.

VACUUM_FSM_EVERY_PAGES

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

Definition at line 201 of file vacuumlazy.c.

VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL

#define VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL   20 /* ms */

Definition at line 178 of file vacuumlazy.c.

VACUUM_TRUNCATE_LOCK_TIMEOUT

#define VACUUM_TRUNCATE_LOCK_TIMEOUT   5000 /* ms */

Definition at line 180 of file vacuumlazy.c.

VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL

#define VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL   50 /* ms */

Definition at line 179 of file vacuumlazy.c.

Typedef Documentation

LVRelState

typedef struct LVRelState LVRelState

LVSavedErrInfo

typedef struct LVSavedErrInfo LVSavedErrInfo

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 223 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

cmpOffsetNumbers()

static int cmpOffsetNumbers ( const void *  a, const void *  b  )

static

Definition at line 1946 of file vacuumlazy.c.

{
    return pg_cmp_u16(*(const OffsetNumber *) a, *(const OffsetNumber *) b);
}

References a, b, and pg_cmp_u16().

Referenced by lazy_scan_prune().

count_nondeletable_pages()

static BlockNumber count_nondeletable_pages ( LVRelState *  vacrel, bool *  lock_waiter_detected  )

static

Definition at line 3389 of file vacuumlazy.c.

{
    StaticAssertDecl((PREFETCH_SIZE & (PREFETCH_SIZE - 1)) == 0,
                     "prefetch size must be power of 2");
 
    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 = vacrel->rel_pages;
    prefetchedUntil = InvalidBlockNumber;
    while (blkno > vacrel->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(vacrel->rel, AccessExclusiveLock))
                {
                    ereport(vacrel->verbose ? INFO : DEBUG2,
                            (errmsg("table \"%s\": suspending truncate due to conflicting lock request",
                                    vacrel->relname)));
 
                    *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(vacrel->rel, MAIN_FORKNUM, pblkno);
                CHECK_FOR_INTERRUPTS();
            }
            prefetchedUntil = prefetchStart;
        }
 
        buf = ReadBufferExtended(vacrel->rel, MAIN_FORKNUM, blkno, RBM_NORMAL,
                                 vacrel->bstrategy);
 
        /* 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.  Even an LP_DEAD item makes truncation unsafe, since
             * we must not have cleaned out its 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 vacrel->nonempty_pages;
}

References AccessExclusiveLock, LVRelState::bstrategy, buf, BUFFER_LOCK_SHARE, BufferGetPage(), CHECK_FOR_INTERRUPTS, DEBUG2, ereport, errmsg(), FirstOffsetNumber, INFO, INSTR_TIME_GET_MICROSEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, InvalidBlockNumber, ItemIdIsUsed, LockBuffer(), LockHasWaitersRelation(), MAIN_FORKNUM, LVRelState::nonempty_pages, OffsetNumberNext, PageGetItemId(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageIsNew(), PREFETCH_SIZE, PrefetchBuffer(), RBM_NORMAL, ReadBufferExtended(), LVRelState::rel, LVRelState::rel_pages, LVRelState::relname, StaticAssertDecl, UnlockReleaseBuffer(), VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and LVRelState::verbose.

Referenced by lazy_truncate_heap().

dead_items_add()

static void dead_items_add ( LVRelState *  vacrel, BlockNumber  blkno, OffsetNumber *  offsets, int  num_offsets  )

static

Definition at line 3597 of file vacuumlazy.c.

{
    const int   prog_index[2] = {
        PROGRESS_VACUUM_NUM_DEAD_ITEM_IDS,
        PROGRESS_VACUUM_DEAD_TUPLE_BYTES
    };
    int64       prog_val[2];
 
    TidStoreSetBlockOffsets(vacrel->dead_items, blkno, offsets, num_offsets);
    vacrel->dead_items_info->num_items += num_offsets;
 
    /* update the progress information */
    prog_val[0] = vacrel->dead_items_info->num_items;
    prog_val[1] = TidStoreMemoryUsage(vacrel->dead_items);
    pgstat_progress_update_multi_param(2, prog_index, prog_val);
}

References LVRelState::dead_items, LVRelState::dead_items_info, VacDeadItemsInfo::num_items, pgstat_progress_update_multi_param(), PROGRESS_VACUUM_DEAD_TUPLE_BYTES, PROGRESS_VACUUM_NUM_DEAD_ITEM_IDS, TidStoreMemoryUsage(), and TidStoreSetBlockOffsets().

Referenced by lazy_scan_noprune(), and lazy_scan_prune().

dead_items_alloc()

static void dead_items_alloc ( LVRelState *  vacrel, int  nworkers  )

static

Definition at line 3532 of file vacuumlazy.c.

{
    VacDeadItemsInfo *dead_items_info;
    int         vac_work_mem = AmAutoVacuumWorkerProcess() &&
        autovacuum_work_mem != -1 ?
        autovacuum_work_mem : maintenance_work_mem;
 
    /*
     * 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 (nworkers >= 0 && vacrel->nindexes > 1 && vacrel->do_index_vacuuming)
    {
        /*
         * Since parallel workers cannot access data in temporary tables, we
         * can't perform parallel vacuum on them.
         */
        if (RelationUsesLocalBuffers(vacrel->rel))
        {
            /*
             * Give warning only if the user explicitly tries to perform a
             * parallel vacuum on the temporary table.
             */
            if (nworkers > 0)
                ereport(WARNING,
                        (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
                                vacrel->relname)));
        }
        else
            vacrel->pvs = parallel_vacuum_init(vacrel->rel, vacrel->indrels,
                                               vacrel->nindexes, nworkers,
                                               vac_work_mem,
                                               vacrel->verbose ? INFO : DEBUG2,
                                               vacrel->bstrategy);
 
        /*
         * If parallel mode started, dead_items and dead_items_info spaces are
         * allocated in DSM.
         */
        if (ParallelVacuumIsActive(vacrel))
        {
            vacrel->dead_items = parallel_vacuum_get_dead_items(vacrel->pvs,
                                                                &vacrel->dead_items_info);
            return;
        }
    }
 
    /*
     * Serial VACUUM case. Allocate both dead_items and dead_items_info
     * locally.
     */
 
    dead_items_info = palloc_object(VacDeadItemsInfo);
    dead_items_info->max_bytes = vac_work_mem * (Size) 1024;
    dead_items_info->num_items = 0;
    vacrel->dead_items_info = dead_items_info;
 
    vacrel->dead_items = TidStoreCreateLocal(dead_items_info->max_bytes, true);
}

References AmAutoVacuumWorkerProcess, autovacuum_work_mem, LVRelState::bstrategy, LVRelState::dead_items, LVRelState::dead_items_info, DEBUG2, LVRelState::do_index_vacuuming, ereport, errmsg(), LVRelState::indrels, INFO, maintenance_work_mem, VacDeadItemsInfo::max_bytes, LVRelState::nindexes, VacDeadItemsInfo::num_items, palloc_object, parallel_vacuum_get_dead_items(), parallel_vacuum_init(), ParallelVacuumIsActive, LVRelState::pvs, LVRelState::rel, RelationUsesLocalBuffers, LVRelState::relname, TidStoreCreateLocal(), LVRelState::verbose, and WARNING.

Referenced by heap_vacuum_rel().

dead_items_cleanup()

static void dead_items_cleanup ( LVRelState *  vacrel )

static

Definition at line 3641 of file vacuumlazy.c.

{
    if (!ParallelVacuumIsActive(vacrel))
    {
        /* Don't bother with pfree here */
        return;
    }
 
    /* End parallel mode */
    parallel_vacuum_end(vacrel->pvs, vacrel->indstats);
    vacrel->pvs = NULL;
}

References LVRelState::indstats, parallel_vacuum_end(), ParallelVacuumIsActive, and LVRelState::pvs.

Referenced by heap_vacuum_rel().

dead_items_reset()

static void dead_items_reset ( LVRelState *  vacrel )

static

Definition at line 3619 of file vacuumlazy.c.

{
    if (ParallelVacuumIsActive(vacrel))
    {
        parallel_vacuum_reset_dead_items(vacrel->pvs);
        vacrel->dead_items = parallel_vacuum_get_dead_items(vacrel->pvs,
                                                            &vacrel->dead_items_info);
        return;
    }
 
    /* Recreate the tidstore with the same max_bytes limitation */
    TidStoreDestroy(vacrel->dead_items);
    vacrel->dead_items = TidStoreCreateLocal(vacrel->dead_items_info->max_bytes, true);
 
    /* Reset the counter */
    vacrel->dead_items_info->num_items = 0;
}

References LVRelState::dead_items, LVRelState::dead_items_info, VacDeadItemsInfo::max_bytes, VacDeadItemsInfo::num_items, parallel_vacuum_get_dead_items(), parallel_vacuum_reset_dead_items(), ParallelVacuumIsActive, LVRelState::pvs, TidStoreCreateLocal(), and TidStoreDestroy().

Referenced by lazy_vacuum().

find_next_unskippable_block()

static void find_next_unskippable_block ( LVRelState *  vacrel, bool *  skipsallvis  )

static

Definition at line 1704 of file vacuumlazy.c.

{
    BlockNumber rel_pages = vacrel->rel_pages;
    BlockNumber next_unskippable_block = vacrel->next_unskippable_block + 1;
    Buffer      next_unskippable_vmbuffer = vacrel->next_unskippable_vmbuffer;
    bool        next_unskippable_eager_scanned = false;
    bool        next_unskippable_allvis;
 
    *skipsallvis = false;
 
    for (;; next_unskippable_block++)
    {
        uint8       mapbits = visibilitymap_get_status(vacrel->rel,
                                                       next_unskippable_block,
                                                       &next_unskippable_vmbuffer);
 
        next_unskippable_allvis = (mapbits & VISIBILITYMAP_ALL_VISIBLE) != 0;
 
        /*
         * At the start of each eager scan region, normal vacuums with eager
         * scanning enabled reset the failure counter, allowing vacuum to
         * resume eager scanning if it had been suspended in the previous
         * region.
         */
        if (next_unskippable_block >= vacrel->next_eager_scan_region_start)
        {
            vacrel->eager_scan_remaining_fails =
                vacrel->eager_scan_max_fails_per_region;
            vacrel->next_eager_scan_region_start += EAGER_SCAN_REGION_SIZE;
        }
 
        /*
         * A block is unskippable if it is not all visible according to the
         * visibility map.
         */
        if (!next_unskippable_allvis)
        {
            Assert((mapbits & VISIBILITYMAP_ALL_FROZEN) == 0);
            break;
        }
 
        /*
         * Caller must scan the last page to determine whether it has tuples
         * (caller must have the opportunity to set vacrel->nonempty_pages).
         * This rule avoids having lazy_truncate_heap() take access-exclusive
         * lock on rel to attempt a truncation that fails anyway, just because
         * there are tuples on the last page (it is likely that there will be
         * tuples on other nearby pages as well, but those can be skipped).
         *
         * Implement this by always treating the last block as unsafe to skip.
         */
        if (next_unskippable_block == rel_pages - 1)
            break;
 
        /* DISABLE_PAGE_SKIPPING makes all skipping unsafe */
        if (!vacrel->skipwithvm)
            break;
 
        /*
         * All-frozen pages cannot contain XIDs < OldestXmin (XIDs that aren't
         * already frozen by now), so this page can be skipped.
         */
        if ((mapbits & VISIBILITYMAP_ALL_FROZEN) != 0)
            continue;
 
        /*
         * Aggressive vacuums cannot skip any all-visible pages that are not
         * also all-frozen.
         */
        if (vacrel->aggressive)
            break;
 
        /*
         * Normal vacuums with eager scanning enabled only skip all-visible
         * but not all-frozen pages if they have hit the failure limit for the
         * current eager scan region.
         */
        if (vacrel->eager_scan_remaining_fails > 0)
        {
            next_unskippable_eager_scanned = true;
            break;
        }
 
        /*
         * All-visible blocks are safe to skip in a normal vacuum. But
         * remember that the final range contains such a block for later.
         */
        *skipsallvis = true;
    }
 
    /* write the local variables back to vacrel */
    vacrel->next_unskippable_block = next_unskippable_block;
    vacrel->next_unskippable_allvis = next_unskippable_allvis;
    vacrel->next_unskippable_eager_scanned = next_unskippable_eager_scanned;
    vacrel->next_unskippable_vmbuffer = next_unskippable_vmbuffer;
}

References LVRelState::aggressive, Assert(), LVRelState::eager_scan_max_fails_per_region, EAGER_SCAN_REGION_SIZE, LVRelState::eager_scan_remaining_fails, LVRelState::next_eager_scan_region_start, LVRelState::next_unskippable_allvis, LVRelState::next_unskippable_block, LVRelState::next_unskippable_eager_scanned, LVRelState::next_unskippable_vmbuffer, LVRelState::rel, LVRelState::rel_pages, LVRelState::skipwithvm, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, and visibilitymap_get_status().

Referenced by heap_vac_scan_next_block().

heap_page_would_be_all_visible()

static bool heap_page_would_be_all_visible ( Relation  rel, Buffer  buf, TransactionId  OldestXmin, OffsetNumber *  deadoffsets, int  ndeadoffsets, bool *  all_frozen, TransactionId *  visibility_cutoff_xid, OffsetNumber *  logging_offnum  )

static

Definition at line 3709 of file vacuumlazy.c.

{
    Page        page = BufferGetPage(buf);
    BlockNumber blockno = BufferGetBlockNumber(buf);
    OffsetNumber offnum,
                maxoff;
    bool        all_visible = true;
    int         matched_dead_count = 0;
 
    *visibility_cutoff_xid = InvalidTransactionId;
    *all_frozen = true;
 
    Assert(ndeadoffsets == 0 || deadoffsets);
 
#ifdef USE_ASSERT_CHECKING
    /* Confirm input deadoffsets[] is strictly sorted */
    if (ndeadoffsets > 1)
    {
        for (int i = 1; i < ndeadoffsets; i++)
            Assert(deadoffsets[i - 1] < deadoffsets[i]);
    }
#endif
 
    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.
         */
        *logging_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))
        {
            if (!deadoffsets ||
                matched_dead_count >= ndeadoffsets ||
                deadoffsets[matched_dead_count] != offnum)
            {
                *all_frozen = all_visible = false;
                break;
            }
            matched_dead_count++;
            continue;
        }
 
        Assert(ItemIdIsNormal(itemid));
 
        tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
        tuple.t_len = ItemIdGetLength(itemid);
        tuple.t_tableOid = RelationGetRelid(rel);
 
        /* Visibility checks may do IO or allocate memory */
        Assert(CritSectionCount == 0);
        switch (HeapTupleSatisfiesVacuum(&tuple, OldestXmin, buf))
        {
            case HEAPTUPLE_LIVE:
                {
                    TransactionId xmin;
 
                    /* Check comments in lazy_scan_prune. */
                    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) &&
                        TransactionIdIsNormal(xmin))
                        *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. */
    *logging_offnum = InvalidOffsetNumber;
 
    return all_visible;
}

References Assert(), buf, BufferGetBlockNumber(), BufferGetPage(), CritSectionCount, 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(), i, InvalidOffsetNumber, InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), RelationGetRelid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdFollows(), TransactionIdIsNormal, and TransactionIdPrecedes().

Referenced by lazy_vacuum_heap_page().

heap_vac_scan_next_block()

static BlockNumber heap_vac_scan_next_block ( ReadStream *  stream, void *  callback_private_data, void *  per_buffer_data  )

static

Definition at line 1599 of file vacuumlazy.c.

{
    BlockNumber next_block;
    LVRelState *vacrel = callback_private_data;
    uint8       blk_info = 0;
 
    /* relies on InvalidBlockNumber + 1 overflowing to 0 on first call */
    next_block = vacrel->current_block + 1;
 
    /* Have we reached the end of the relation? */
    if (next_block >= vacrel->rel_pages)
    {
        if (BufferIsValid(vacrel->next_unskippable_vmbuffer))
        {
            ReleaseBuffer(vacrel->next_unskippable_vmbuffer);
            vacrel->next_unskippable_vmbuffer = InvalidBuffer;
        }
        return InvalidBlockNumber;
    }
 
    /*
     * We must be in one of the three following states:
     */
    if (next_block > vacrel->next_unskippable_block ||
        vacrel->next_unskippable_block == InvalidBlockNumber)
    {
        /*
         * 1. We have just processed an unskippable block (or we're at the
         * beginning of the scan).  Find the next unskippable block using the
         * visibility map.
         */
        bool        skipsallvis;
 
        find_next_unskippable_block(vacrel, &skipsallvis);
 
        /*
         * We now know the next block that we must process.  It can be the
         * next block after the one we just processed, or something further
         * ahead.  If it's further ahead, we can jump to it, but we choose to
         * do so only if 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.  Skipping such a range might even discourage sequential
         * detection.
         *
         * This test also enables more frequent relfrozenxid advancement
         * during non-aggressive VACUUMs.  If the range has any all-visible
         * pages then skipping makes updating relfrozenxid unsafe, which is a
         * real downside.
         */
        if (vacrel->next_unskippable_block - next_block >= SKIP_PAGES_THRESHOLD)
        {
            next_block = vacrel->next_unskippable_block;
            if (skipsallvis)
                vacrel->skippedallvis = true;
        }
    }
 
    /* Now we must be in one of the two remaining states: */
    if (next_block < vacrel->next_unskippable_block)
    {
        /*
         * 2. We are processing a range of blocks that we could have skipped
         * but chose not to.  We know that they are all-visible in the VM,
         * otherwise they would've been unskippable.
         */
        vacrel->current_block = next_block;
        blk_info |= VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM;
        *((uint8 *) per_buffer_data) = blk_info;
        return vacrel->current_block;
    }
    else
    {
        /*
         * 3. We reached the next unskippable block.  Process it.  On next
         * iteration, we will be back in state 1.
         */
        Assert(next_block == vacrel->next_unskippable_block);
 
        vacrel->current_block = next_block;
        if (vacrel->next_unskippable_allvis)
            blk_info |= VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM;
        if (vacrel->next_unskippable_eager_scanned)
            blk_info |= VAC_BLK_WAS_EAGER_SCANNED;
        *((uint8 *) per_buffer_data) = blk_info;
        return vacrel->current_block;
    }
}

References Assert(), BufferIsValid(), LVRelState::current_block, find_next_unskippable_block(), InvalidBlockNumber, InvalidBuffer, LVRelState::next_unskippable_allvis, LVRelState::next_unskippable_block, LVRelState::next_unskippable_eager_scanned, LVRelState::next_unskippable_vmbuffer, LVRelState::rel_pages, ReleaseBuffer(), SKIP_PAGES_THRESHOLD, LVRelState::skippedallvis, VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM, and VAC_BLK_WAS_EAGER_SCANNED.

Referenced by lazy_scan_heap().

heap_vacuum_eager_scan_setup()

static void heap_vacuum_eager_scan_setup ( LVRelState *  vacrel, const VacuumParams  params  )

static

Definition at line 500 of file vacuumlazy.c.

{
    uint32      randseed;
    BlockNumber allvisible;
    BlockNumber allfrozen;
    float       first_region_ratio;
    bool        oldest_unfrozen_before_cutoff = false;
 
    /*
     * Initialize eager scan management fields to their disabled values.
     * Aggressive vacuums, normal vacuums of small tables, and normal vacuums
     * of tables without sufficiently old tuples disable eager scanning.
     */
    vacrel->next_eager_scan_region_start = InvalidBlockNumber;
    vacrel->eager_scan_max_fails_per_region = 0;
    vacrel->eager_scan_remaining_fails = 0;
    vacrel->eager_scan_remaining_successes = 0;
 
    /* If eager scanning is explicitly disabled, just return. */
    if (params.max_eager_freeze_failure_rate == 0)
        return;
 
    /*
     * The caller will have determined whether or not an aggressive vacuum is
     * required by either the vacuum parameters or the relative age of the
     * oldest unfrozen transaction IDs. An aggressive vacuum must scan every
     * all-visible page to safely advance the relfrozenxid and/or relminmxid,
     * so scans of all-visible pages are not considered eager.
     */
    if (vacrel->aggressive)
        return;
 
    /*
     * Aggressively vacuuming a small relation shouldn't take long, so it
     * isn't worth amortizing. We use two times the region size as the size
     * cutoff because the eager scan start block is a random spot somewhere in
     * the first region, making the second region the first to be eager
     * scanned normally.
     */
    if (vacrel->rel_pages < 2 * EAGER_SCAN_REGION_SIZE)
        return;
 
    /*
     * We only want to enable eager scanning if we are likely to be able to
     * freeze some of the pages in the relation.
     *
     * Tuples with XIDs older than OldestXmin or MXIDs older than OldestMxact
     * are technically freezable, but we won't freeze them unless the criteria
     * for opportunistic freezing is met. Only tuples with XIDs/MXIDs older
     * than the FreezeLimit/MultiXactCutoff are frozen in the common case.
     *
     * So, as a heuristic, we wait until the FreezeLimit has advanced past the
     * relfrozenxid or the MultiXactCutoff has advanced past the relminmxid to
     * enable eager scanning.
     */
    if (TransactionIdIsNormal(vacrel->cutoffs.relfrozenxid) &&
        TransactionIdPrecedes(vacrel->cutoffs.relfrozenxid,
                              vacrel->cutoffs.FreezeLimit))
        oldest_unfrozen_before_cutoff = true;
 
    if (!oldest_unfrozen_before_cutoff &&
        MultiXactIdIsValid(vacrel->cutoffs.relminmxid) &&
        MultiXactIdPrecedes(vacrel->cutoffs.relminmxid,
                            vacrel->cutoffs.MultiXactCutoff))
        oldest_unfrozen_before_cutoff = true;
 
    if (!oldest_unfrozen_before_cutoff)
        return;
 
    /* We have met the criteria to eagerly scan some pages. */
 
    /*
     * Our success cap is MAX_EAGER_FREEZE_SUCCESS_RATE of the number of
     * all-visible but not all-frozen blocks in the relation.
     */
    visibilitymap_count(vacrel->rel, &allvisible, &allfrozen);
 
    vacrel->eager_scan_remaining_successes =
        (BlockNumber) (MAX_EAGER_FREEZE_SUCCESS_RATE *
                       (allvisible - allfrozen));
 
    /* If every all-visible page is frozen, eager scanning is disabled. */
    if (vacrel->eager_scan_remaining_successes == 0)
        return;
 
    /*
     * Now calculate the bounds of the first eager scan region. Its end block
     * will be a random spot somewhere in the first EAGER_SCAN_REGION_SIZE
     * blocks. This affects the bounds of all subsequent regions and avoids
     * eager scanning and failing to freeze the same blocks each vacuum of the
     * relation.
     */
    randseed = pg_prng_uint32(&pg_global_prng_state);
 
    vacrel->next_eager_scan_region_start = randseed % EAGER_SCAN_REGION_SIZE;
 
    Assert(params.max_eager_freeze_failure_rate > 0 &&
           params.max_eager_freeze_failure_rate <= 1);
 
    vacrel->eager_scan_max_fails_per_region =
        params.max_eager_freeze_failure_rate *
        EAGER_SCAN_REGION_SIZE;
 
    /*
     * The first region will be smaller than subsequent regions. As such,
     * adjust the eager freeze failures tolerated for this region.
     */
    first_region_ratio = 1 - (float) vacrel->next_eager_scan_region_start /
        EAGER_SCAN_REGION_SIZE;
 
    vacrel->eager_scan_remaining_fails =
        vacrel->eager_scan_max_fails_per_region *
        first_region_ratio;
}

References LVRelState::aggressive, Assert(), LVRelState::cutoffs, LVRelState::eager_scan_max_fails_per_region, EAGER_SCAN_REGION_SIZE, LVRelState::eager_scan_remaining_fails, LVRelState::eager_scan_remaining_successes, VacuumCutoffs::FreezeLimit, InvalidBlockNumber, VacuumParams::max_eager_freeze_failure_rate, MAX_EAGER_FREEZE_SUCCESS_RATE, VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), LVRelState::next_eager_scan_region_start, pg_global_prng_state, pg_prng_uint32(), LVRelState::rel, LVRelState::rel_pages, VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, TransactionIdIsNormal, TransactionIdPrecedes(), and visibilitymap_count().

Referenced by heap_vacuum_rel().

heap_vacuum_rel()

void heap_vacuum_rel	(	Relation	rel,
		const VacuumParams	params,
		BufferAccessStrategy	bstrategy
	)

Definition at line 627 of file vacuumlazy.c.

{
    LVRelState *vacrel;
    bool        verbose,
                instrument,
                skipwithvm,
                frozenxid_updated,
                minmulti_updated;
    BlockNumber orig_rel_pages,
                new_rel_pages,
                new_rel_allvisible,
                new_rel_allfrozen;
    PGRUsage    ru0;
    TimestampTz starttime = 0;
    PgStat_Counter startreadtime = 0,
                startwritetime = 0;
    WalUsage    startwalusage = pgWalUsage;
    BufferUsage startbufferusage = pgBufferUsage;
    ErrorContextCallback errcallback;
    char      **indnames = NULL;
 
    verbose = (params.options & VACOPT_VERBOSE) != 0;
    instrument = (verbose || (AmAutoVacuumWorkerProcess() &&
                              params.log_vacuum_min_duration >= 0));
    if (instrument)
    {
        pg_rusage_init(&ru0);
        if (track_io_timing)
        {
            startreadtime = pgStatBlockReadTime;
            startwritetime = pgStatBlockWriteTime;
        }
    }
 
    /* Used for instrumentation and stats report */
    starttime = GetCurrentTimestamp();
 
    pgstat_progress_start_command(PROGRESS_COMMAND_VACUUM,
                                  RelationGetRelid(rel));
    if (AmAutoVacuumWorkerProcess())
        pgstat_progress_update_param(PROGRESS_VACUUM_STARTED_BY,
                                     params.is_wraparound
                                     ? PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM_WRAPAROUND
                                     : PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM);
    else
        pgstat_progress_update_param(PROGRESS_VACUUM_STARTED_BY,
                                     PROGRESS_VACUUM_STARTED_BY_MANUAL);
 
    /*
     * Setup error traceback support for ereport() first.  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, we update
     * the state so that the error context callback always display current
     * information.
     *
     * Copy the names of heap rel into local memory for error reporting
     * purposes, too.  It isn't always safe to assume that we can get the name
     * of each rel.  It's convenient for code in lazy_scan_heap to always use
     * these temp copies.
     */
    vacrel = palloc0_object(LVRelState);
    vacrel->dbname = get_database_name(MyDatabaseId);
    vacrel->relnamespace = get_namespace_name(RelationGetNamespace(rel));
    vacrel->relname = pstrdup(RelationGetRelationName(rel));
    vacrel->indname = NULL;
    vacrel->phase = VACUUM_ERRCB_PHASE_UNKNOWN;
    vacrel->verbose = verbose;
    errcallback.callback = vacuum_error_callback;
    errcallback.arg = vacrel;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;
 
    /* Set up high level stuff about rel and its indexes */
    vacrel->rel = rel;
    vac_open_indexes(vacrel->rel, RowExclusiveLock, &vacrel->nindexes,
                     &vacrel->indrels);
    vacrel->bstrategy = bstrategy;
    if (instrument && vacrel->nindexes > 0)
    {
        /* Copy index names used by instrumentation (not error reporting) */
        indnames = palloc_array(char *, vacrel->nindexes);
        for (int i = 0; i < vacrel->nindexes; i++)
            indnames[i] = pstrdup(RelationGetRelationName(vacrel->indrels[i]));
    }
 
    /*
     * The index_cleanup param either disables index vacuuming and cleanup or
     * forces it to go ahead when we would otherwise apply the index bypass
     * optimization.  The default is 'auto', which leaves the final decision
     * up to lazy_vacuum().
     *
     * The truncate param allows user to avoid attempting relation truncation,
     * though it can't force truncation to happen.
     */
    Assert(params.index_cleanup != VACOPTVALUE_UNSPECIFIED);
    Assert(params.truncate != VACOPTVALUE_UNSPECIFIED &&
           params.truncate != VACOPTVALUE_AUTO);
 
    /*
     * While VacuumFailSafeActive is reset to false before calling this, we
     * still need to reset it here due to recursive calls.
     */
    VacuumFailsafeActive = false;
    vacrel->consider_bypass_optimization = true;
    vacrel->do_index_vacuuming = true;
    vacrel->do_index_cleanup = true;
    vacrel->do_rel_truncate = (params.truncate != VACOPTVALUE_DISABLED);
    if (params.index_cleanup == VACOPTVALUE_DISABLED)
    {
        /* Force disable index vacuuming up-front */
        vacrel->do_index_vacuuming = false;
        vacrel->do_index_cleanup = false;
    }
    else if (params.index_cleanup == VACOPTVALUE_ENABLED)
    {
        /* Force index vacuuming.  Note that failsafe can still bypass. */
        vacrel->consider_bypass_optimization = false;
    }
    else
    {
        /* Default/auto, make all decisions dynamically */
        Assert(params.index_cleanup == VACOPTVALUE_AUTO);
    }
 
    /* Initialize page counters explicitly (be tidy) */
    vacrel->scanned_pages = 0;
    vacrel->eager_scanned_pages = 0;
    vacrel->removed_pages = 0;
    vacrel->new_frozen_tuple_pages = 0;
    vacrel->lpdead_item_pages = 0;
    vacrel->missed_dead_pages = 0;
    vacrel->nonempty_pages = 0;
    /* dead_items_alloc allocates vacrel->dead_items later on */
 
    /* Allocate/initialize output statistics state */
    vacrel->new_rel_tuples = 0;
    vacrel->new_live_tuples = 0;
    vacrel->indstats = (IndexBulkDeleteResult **)
        palloc0(vacrel->nindexes * sizeof(IndexBulkDeleteResult *));
 
    /* Initialize remaining counters (be tidy) */
    vacrel->num_index_scans = 0;
    vacrel->tuples_deleted = 0;
    vacrel->tuples_frozen = 0;
    vacrel->lpdead_items = 0;
    vacrel->live_tuples = 0;
    vacrel->recently_dead_tuples = 0;
    vacrel->missed_dead_tuples = 0;
 
    vacrel->vm_new_visible_pages = 0;
    vacrel->vm_new_visible_frozen_pages = 0;
    vacrel->vm_new_frozen_pages = 0;
 
    /*
     * Get cutoffs that determine which deleted tuples are considered DEAD,
     * not just RECENTLY_DEAD, and which XIDs/MXIDs to freeze.  Then determine
     * the extent of the blocks that we'll scan in lazy_scan_heap.  It has to
     * happen in this order to ensure that the OldestXmin cutoff field works
     * as an upper bound on the XIDs stored in the pages we'll actually scan
     * (NewRelfrozenXid tracking must never be allowed to miss unfrozen XIDs).
     *
     * Next acquire vistest, a related cutoff that's used in pruning.  We use
     * vistest in combination with OldestXmin to ensure that
     * heap_page_prune_and_freeze() always removes any deleted tuple whose
     * xmax is < OldestXmin.  lazy_scan_prune must never become confused about
     * whether a tuple should be frozen or removed.  (In the future we might
     * want to teach lazy_scan_prune to recompute vistest from time to time,
     * to increase the number of dead tuples it can prune away.)
     */
    vacrel->aggressive = vacuum_get_cutoffs(rel, params, &vacrel->cutoffs);
    vacrel->rel_pages = orig_rel_pages = RelationGetNumberOfBlocks(rel);
    vacrel->vistest = GlobalVisTestFor(rel);
 
    /* Initialize state used to track oldest extant XID/MXID */
    vacrel->NewRelfrozenXid = vacrel->cutoffs.OldestXmin;
    vacrel->NewRelminMxid = vacrel->cutoffs.OldestMxact;
 
    /*
     * Initialize state related to tracking all-visible page skipping. This is
     * very important to determine whether or not it is safe to advance the
     * relfrozenxid/relminmxid.
     */
    vacrel->skippedallvis = false;
    skipwithvm = true;
    if (params.options & VACOPT_DISABLE_PAGE_SKIPPING)
    {
        /*
         * Force aggressive mode, and disable skipping blocks using the
         * visibility map (even those set all-frozen)
         */
        vacrel->aggressive = true;
        skipwithvm = false;
    }
 
    vacrel->skipwithvm = skipwithvm;
 
    /*
     * Set up eager scan tracking state. This must happen after determining
     * whether or not the vacuum must be aggressive, because only normal
     * vacuums use the eager scan algorithm.
     */
    heap_vacuum_eager_scan_setup(vacrel, params);
 
    /* Report the vacuum mode: 'normal' or 'aggressive' */
    pgstat_progress_update_param(PROGRESS_VACUUM_MODE,
                                 vacrel->aggressive
                                 ? PROGRESS_VACUUM_MODE_AGGRESSIVE
                                 : PROGRESS_VACUUM_MODE_NORMAL);
 
    if (verbose)
    {
        if (vacrel->aggressive)
            ereport(INFO,
                    (errmsg("aggressively vacuuming \"%s.%s.%s\"",
                            vacrel->dbname, vacrel->relnamespace,
                            vacrel->relname)));
        else
            ereport(INFO,
                    (errmsg("vacuuming \"%s.%s.%s\"",
                            vacrel->dbname, vacrel->relnamespace,
                            vacrel->relname)));
    }
 
    /*
     * Allocate dead_items memory using dead_items_alloc.  This handles
     * parallel VACUUM initialization as part of allocating shared memory
     * space used for dead_items.  (But do a failsafe precheck first, to
     * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
     * is already dangerously old.)
     */
    lazy_check_wraparound_failsafe(vacrel);
    dead_items_alloc(vacrel, params.nworkers);
 
    /*
     * Call lazy_scan_heap to perform all required heap pruning, index
     * vacuuming, and heap vacuuming (plus related processing)
     */
    lazy_scan_heap(vacrel);
 
    /*
     * Free resources managed by dead_items_alloc.  This ends parallel mode in
     * passing when necessary.
     */
    dead_items_cleanup(vacrel);
    Assert(!IsInParallelMode());
 
    /*
     * Update pg_class entries for each of rel's indexes where appropriate.
     *
     * Unlike the later update to rel's pg_class entry, this is not critical.
     * Maintains relpages/reltuples statistics used by the planner only.
     */
    if (vacrel->do_index_cleanup)
        update_relstats_all_indexes(vacrel);
 
    /* Done with rel's indexes */
    vac_close_indexes(vacrel->nindexes, vacrel->indrels, NoLock);
 
    /* Optionally truncate rel */
    if (should_attempt_truncation(vacrel))
        lazy_truncate_heap(vacrel);
 
    /* 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);
 
    /*
     * Prepare to update rel's pg_class entry.
     *
     * Aggressive VACUUMs must always be able to advance relfrozenxid to a
     * value >= FreezeLimit, and relminmxid to a value >= MultiXactCutoff.
     * Non-aggressive VACUUMs may advance them by any amount, or not at all.
     */
    Assert(vacrel->NewRelfrozenXid == vacrel->cutoffs.OldestXmin ||
           TransactionIdPrecedesOrEquals(vacrel->aggressive ? vacrel->cutoffs.FreezeLimit :
                                         vacrel->cutoffs.relfrozenxid,
                                         vacrel->NewRelfrozenXid));
    Assert(vacrel->NewRelminMxid == vacrel->cutoffs.OldestMxact ||
           MultiXactIdPrecedesOrEquals(vacrel->aggressive ? vacrel->cutoffs.MultiXactCutoff :
                                       vacrel->cutoffs.relminmxid,
                                       vacrel->NewRelminMxid));
    if (vacrel->skippedallvis)
    {
        /*
         * Must keep original relfrozenxid in a non-aggressive VACUUM that
         * chose to skip an all-visible page range.  The state that tracks new
         * values will have missed unfrozen XIDs from the pages we skipped.
         */
        Assert(!vacrel->aggressive);
        vacrel->NewRelfrozenXid = InvalidTransactionId;
        vacrel->NewRelminMxid = InvalidMultiXactId;
    }
 
    /*
     * For safety, clamp relallvisible to be not more than what we're setting
     * pg_class.relpages to
     */
    new_rel_pages = vacrel->rel_pages;  /* After possible rel truncation */
    visibilitymap_count(rel, &new_rel_allvisible, &new_rel_allfrozen);
    if (new_rel_allvisible > new_rel_pages)
        new_rel_allvisible = new_rel_pages;
 
    /*
     * An all-frozen block _must_ be all-visible. As such, clamp the count of
     * all-frozen blocks to the count of all-visible blocks. This matches the
     * clamping of relallvisible above.
     */
    if (new_rel_allfrozen > new_rel_allvisible)
        new_rel_allfrozen = new_rel_allvisible;
 
    /*
     * Now actually update rel's pg_class entry.
     *
     * In principle new_live_tuples could be -1 indicating that we (still)
     * don't know the tuple count.  In practice that can't happen, since we
     * scan every page that isn't skipped using the visibility map.
     */
    vac_update_relstats(rel, new_rel_pages, vacrel->new_live_tuples,
                        new_rel_allvisible, new_rel_allfrozen,
                        vacrel->nindexes > 0,
                        vacrel->NewRelfrozenXid, vacrel->NewRelminMxid,
                        &frozenxid_updated, &minmulti_updated, false);
 
    /*
     * Report results to the cumulative stats system, too.
     *
     * Deliberately avoid telling the stats system about LP_DEAD items that
     * remain in the table due to VACUUM bypassing index and heap vacuuming.
     * ANALYZE will consider the remaining LP_DEAD items to be dead "tuples".
     * It seems like a good idea to err on the side of not vacuuming again too
     * soon in cases where the failsafe prevented significant amounts of heap
     * vacuuming.
     */
    pgstat_report_vacuum(RelationGetRelid(rel),
                         rel->rd_rel->relisshared,
                         Max(vacrel->new_live_tuples, 0),
                         vacrel->recently_dead_tuples +
                         vacrel->missed_dead_tuples,
                         starttime);
    pgstat_progress_end_command();
 
    if (instrument)
    {
        TimestampTz endtime = GetCurrentTimestamp();
 
        if (verbose || params.log_vacuum_min_duration == 0 ||
            TimestampDifferenceExceeds(starttime, endtime,
                                       params.log_vacuum_min_duration))
        {
            long        secs_dur;
            int         usecs_dur;
            WalUsage    walusage;
            BufferUsage bufferusage;
            StringInfoData buf;
            char       *msgfmt;
            int32       diff;
            double      read_rate = 0,
                        write_rate = 0;
            int64       total_blks_hit;
            int64       total_blks_read;
            int64       total_blks_dirtied;
 
            TimestampDifference(starttime, endtime, &secs_dur, &usecs_dur);
            memset(&walusage, 0, sizeof(WalUsage));
            WalUsageAccumDiff(&walusage, &pgWalUsage, &startwalusage);
            memset(&bufferusage, 0, sizeof(BufferUsage));
            BufferUsageAccumDiff(&bufferusage, &pgBufferUsage, &startbufferusage);
 
            total_blks_hit = bufferusage.shared_blks_hit +
                bufferusage.local_blks_hit;
            total_blks_read = bufferusage.shared_blks_read +
                bufferusage.local_blks_read;
            total_blks_dirtied = bufferusage.shared_blks_dirtied +
                bufferusage.local_blks_dirtied;
 
            initStringInfo(&buf);
            if (verbose)
            {
                /*
                 * Aggressiveness already reported earlier, in dedicated
                 * VACUUM VERBOSE ereport
                 */
                Assert(!params.is_wraparound);
                msgfmt = _("finished vacuuming \"%s.%s.%s\": index scans: %d\n");
            }
            else if (params.is_wraparound)
            {
                /*
                 * While it's possible for a VACUUM to be both is_wraparound
                 * and !aggressive, that's just a corner-case -- is_wraparound
                 * implies aggressive.  Produce distinct output for the corner
                 * case all the same, just in case.
                 */
                if (vacrel->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 (vacrel->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,
                             vacrel->dbname,
                             vacrel->relnamespace,
                             vacrel->relname,
                             vacrel->num_index_scans);
            appendStringInfo(&buf, _("pages: %u removed, %u remain, %u scanned (%.2f%% of total), %u eagerly scanned\n"),
                             vacrel->removed_pages,
                             new_rel_pages,
                             vacrel->scanned_pages,
                             orig_rel_pages == 0 ? 100.0 :
                             100.0 * vacrel->scanned_pages /
                             orig_rel_pages,
                             vacrel->eager_scanned_pages);
            appendStringInfo(&buf,
                             _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
                             vacrel->tuples_deleted,
                             (int64) vacrel->new_rel_tuples,
                             vacrel->recently_dead_tuples);
            if (vacrel->missed_dead_tuples > 0)
                appendStringInfo(&buf,
                                 _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
                                 vacrel->missed_dead_tuples,
                                 vacrel->missed_dead_pages);
            diff = (int32) (ReadNextTransactionId() -
                            vacrel->cutoffs.OldestXmin);
            appendStringInfo(&buf,
                             _("removable cutoff: %u, which was %d XIDs old when operation ended\n"),
                             vacrel->cutoffs.OldestXmin, diff);
            if (frozenxid_updated)
            {
                diff = (int32) (vacrel->NewRelfrozenXid -
                                vacrel->cutoffs.relfrozenxid);
                appendStringInfo(&buf,
                                 _("new relfrozenxid: %u, which is %d XIDs ahead of previous value\n"),
                                 vacrel->NewRelfrozenXid, diff);
            }
            if (minmulti_updated)
            {
                diff = (int32) (vacrel->NewRelminMxid -
                                vacrel->cutoffs.relminmxid);
                appendStringInfo(&buf,
                                 _("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"),
                                 vacrel->NewRelminMxid, diff);
            }
            appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %" PRId64 " tuples frozen\n"),
                             vacrel->new_frozen_tuple_pages,
                             orig_rel_pages == 0 ? 100.0 :
                             100.0 * vacrel->new_frozen_tuple_pages /
                             orig_rel_pages,
                             vacrel->tuples_frozen);
 
            appendStringInfo(&buf,
                             _("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
                             vacrel->vm_new_visible_pages,
                             vacrel->vm_new_visible_frozen_pages +
                             vacrel->vm_new_frozen_pages,
                             vacrel->vm_new_frozen_pages);
            if (vacrel->do_index_vacuuming)
            {
                if (vacrel->nindexes == 0 || vacrel->num_index_scans == 0)
                    appendStringInfoString(&buf, _("index scan not needed: "));
                else
                    appendStringInfoString(&buf, _("index scan needed: "));
 
                msgfmt = _("%u pages from table (%.2f%% of total) had %" PRId64 " dead item identifiers removed\n");
            }
            else
            {
                if (!VacuumFailsafeActive)
                    appendStringInfoString(&buf, _("index scan bypassed: "));
                else
                    appendStringInfoString(&buf, _("index scan bypassed by failsafe: "));
 
                msgfmt = _("%u pages from table (%.2f%% of total) have %" PRId64 " dead item identifiers\n");
            }
            appendStringInfo(&buf, msgfmt,
                             vacrel->lpdead_item_pages,
                             orig_rel_pages == 0 ? 100.0 :
                             100.0 * vacrel->lpdead_item_pages / orig_rel_pages,
                             vacrel->lpdead_items);
            for (int i = 0; i < vacrel->nindexes; i++)
            {
                IndexBulkDeleteResult *istat = vacrel->indstats[i];
 
                if (!istat)
                    continue;
 
                appendStringInfo(&buf,
                                 _("index \"%s\": pages: %u in total, %u newly deleted, %u currently deleted, %u reusable\n"),
                                 indnames[i],
                                 istat->num_pages,
                                 istat->pages_newly_deleted,
                                 istat->pages_deleted,
                                 istat->pages_free);
            }
            if (track_cost_delay_timing)
            {
                /*
                 * We bypass the changecount mechanism because this value is
                 * only updated by the calling process.  We also rely on the
                 * above call to pgstat_progress_end_command() to not clear
                 * the st_progress_param array.
                 */
                appendStringInfo(&buf, _("delay time: %.3f ms\n"),
                                 (double) MyBEEntry->st_progress_param[PROGRESS_VACUUM_DELAY_TIME] / 1000000.0);
            }
            if (track_io_timing)
            {
                double      read_ms = (double) (pgStatBlockReadTime - startreadtime) / 1000;
                double      write_ms = (double) (pgStatBlockWriteTime - startwritetime) / 1000;
 
                appendStringInfo(&buf, _("I/O timings: read: %.3f ms, write: %.3f ms\n"),
                                 read_ms, write_ms);
            }
            if (secs_dur > 0 || usecs_dur > 0)
            {
                read_rate = (double) BLCKSZ * total_blks_read /
                    (1024 * 1024) / (secs_dur + usecs_dur / 1000000.0);
                write_rate = (double) BLCKSZ * total_blks_dirtied /
                    (1024 * 1024) / (secs_dur + usecs_dur / 1000000.0);
            }
            appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
                             read_rate, write_rate);
            appendStringInfo(&buf,
                             _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
                             total_blks_hit,
                             total_blks_read,
                             total_blks_dirtied);
            appendStringInfo(&buf,
                             _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRIu64 " full page image bytes, %" PRId64 " buffers full\n"),
                             walusage.wal_records,
                             walusage.wal_fpi,
                             walusage.wal_bytes,
                             walusage.wal_fpi_bytes,
                             walusage.wal_buffers_full);
            appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
 
            ereport(verbose ? INFO : LOG,
                    (errmsg_internal("%s", buf.data)));
            pfree(buf.data);
        }
    }
 
    /* Cleanup index statistics and index names */
    for (int i = 0; i < vacrel->nindexes; i++)
    {
        if (vacrel->indstats[i])
            pfree(vacrel->indstats[i]);
 
        if (instrument)
            pfree(indnames[i]);
    }
}

References _, LVRelState::aggressive, AmAutoVacuumWorkerProcess, appendStringInfo(), appendStringInfoString(), ErrorContextCallback::arg, Assert(), LVRelState::bstrategy, buf, BufferUsageAccumDiff(), ErrorContextCallback::callback, LVRelState::consider_bypass_optimization, LVRelState::cutoffs, LVRelState::dbname, dead_items_alloc(), dead_items_cleanup(), LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, LVRelState::do_rel_truncate, LVRelState::eager_scanned_pages, ereport, errmsg(), errmsg_internal(), error_context_stack, VacuumCutoffs::FreezeLimit, get_database_name(), get_namespace_name(), GetCurrentTimestamp(), GlobalVisTestFor(), heap_vacuum_eager_scan_setup(), i, VacuumParams::index_cleanup, LVRelState::indname, LVRelState::indrels, LVRelState::indstats, INFO, initStringInfo(), InvalidMultiXactId, InvalidTransactionId, VacuumParams::is_wraparound, IsInParallelMode(), lazy_check_wraparound_failsafe(), lazy_scan_heap(), lazy_truncate_heap(), LVRelState::live_tuples, BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, LOG, VacuumParams::log_vacuum_min_duration, LVRelState::lpdead_item_pages, LVRelState::lpdead_items, Max, LVRelState::missed_dead_pages, LVRelState::missed_dead_tuples, VacuumCutoffs::MultiXactCutoff, MultiXactIdPrecedesOrEquals(), MyBEEntry, MyDatabaseId, LVRelState::new_frozen_tuple_pages, LVRelState::new_live_tuples, LVRelState::new_rel_tuples, LVRelState::NewRelfrozenXid, LVRelState::NewRelminMxid, LVRelState::nindexes, NoLock, LVRelState::nonempty_pages, LVRelState::num_index_scans, IndexBulkDeleteResult::num_pages, VacuumParams::nworkers, VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, VacuumParams::options, IndexBulkDeleteResult::pages_deleted, IndexBulkDeleteResult::pages_free, IndexBulkDeleteResult::pages_newly_deleted, palloc0(), palloc0_object, palloc_array, pfree(), pg_rusage_init(), pg_rusage_show(), pgBufferUsage, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), pgstat_report_vacuum(), pgStatBlockReadTime, pgStatBlockWriteTime, pgWalUsage, LVRelState::phase, ErrorContextCallback::previous, PROGRESS_COMMAND_VACUUM, PROGRESS_VACUUM_DELAY_TIME, PROGRESS_VACUUM_MODE, PROGRESS_VACUUM_MODE_AGGRESSIVE, PROGRESS_VACUUM_MODE_NORMAL, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_FINAL_CLEANUP, PROGRESS_VACUUM_STARTED_BY, PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM, PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM_WRAPAROUND, PROGRESS_VACUUM_STARTED_BY_MANUAL, pstrdup(), RelationData::rd_rel, ReadNextTransactionId(), LVRelState::recently_dead_tuples, LVRelState::rel, LVRelState::rel_pages, RelationGetNamespace, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, LVRelState::relname, LVRelState::relnamespace, LVRelState::removed_pages, RowExclusiveLock, LVRelState::scanned_pages, BufferUsage::shared_blks_dirtied, BufferUsage::shared_blks_hit, BufferUsage::shared_blks_read, should_attempt_truncation(), LVRelState::skippedallvis, LVRelState::skipwithvm, PgBackendStatus::st_progress_param, TimestampDifference(), TimestampDifferenceExceeds(), track_cost_delay_timing, track_io_timing, TransactionIdPrecedesOrEquals(), VacuumParams::truncate, LVRelState::tuples_deleted, LVRelState::tuples_frozen, update_relstats_all_indexes(), vac_close_indexes(), vac_open_indexes(), vac_update_relstats(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_VERBOSE, VACOPTVALUE_AUTO, VACOPTVALUE_DISABLED, VACOPTVALUE_ENABLED, VACOPTVALUE_UNSPECIFIED, VACUUM_ERRCB_PHASE_UNKNOWN, vacuum_error_callback(), vacuum_get_cutoffs(), VacuumFailsafeActive, LVRelState::verbose, verbose, visibilitymap_count(), LVRelState::vistest, LVRelState::vm_new_frozen_pages, LVRelState::vm_new_visible_frozen_pages, LVRelState::vm_new_visible_pages, WalUsage::wal_buffers_full, WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_fpi_bytes, WalUsage::wal_records, and WalUsageAccumDiff().

lazy_check_wraparound_failsafe()

static bool lazy_check_wraparound_failsafe ( LVRelState *  vacrel )

static

Definition at line 3007 of file vacuumlazy.c.

{
    /* Don't warn more than once per VACUUM */
    if (VacuumFailsafeActive)
        return true;
 
    if (unlikely(vacuum_xid_failsafe_check(&vacrel->cutoffs)))
    {
        const int   progress_index[] = {
            PROGRESS_VACUUM_INDEXES_TOTAL,
            PROGRESS_VACUUM_INDEXES_PROCESSED,
            PROGRESS_VACUUM_MODE
        };
        int64       progress_val[3] = {0, 0, PROGRESS_VACUUM_MODE_FAILSAFE};
 
        VacuumFailsafeActive = true;
 
        /*
         * Abandon use of a buffer access strategy to allow use of all of
         * shared buffers.  We assume the caller who allocated the memory for
         * the BufferAccessStrategy will free it.
         */
        vacrel->bstrategy = NULL;
 
        /* Disable index vacuuming, index cleanup, and heap rel truncation */
        vacrel->do_index_vacuuming = false;
        vacrel->do_index_cleanup = false;
        vacrel->do_rel_truncate = false;
 
        /* Reset the progress counters and set the failsafe mode */
        pgstat_progress_update_multi_param(3, progress_index, progress_val);
 
        ereport(WARNING,
                (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
                        vacrel->dbname, vacrel->relnamespace, vacrel->relname,
                        vacrel->num_index_scans),
                 errdetail("The table's relfrozenxid or relminmxid is too far in the past."),
                 errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
                         "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
 
        /* Stop applying cost limits from this point on */
        VacuumCostActive = false;
        VacuumCostBalance = 0;
 
        return true;
    }
 
    return false;
}

References LVRelState::bstrategy, LVRelState::cutoffs, LVRelState::dbname, LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, LVRelState::do_rel_truncate, ereport, errdetail(), errhint(), errmsg(), LVRelState::num_index_scans, pgstat_progress_update_multi_param(), PROGRESS_VACUUM_INDEXES_PROCESSED, PROGRESS_VACUUM_INDEXES_TOTAL, PROGRESS_VACUUM_MODE, PROGRESS_VACUUM_MODE_FAILSAFE, LVRelState::relname, LVRelState::relnamespace, unlikely, vacuum_xid_failsafe_check(), VacuumCostActive, VacuumCostBalance, VacuumFailsafeActive, and WARNING.

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

lazy_cleanup_all_indexes()

static void lazy_cleanup_all_indexes ( LVRelState *  vacrel )

static

Definition at line 3061 of file vacuumlazy.c.

{
    double      reltuples = vacrel->new_rel_tuples;
    bool        estimated_count = vacrel->scanned_pages < vacrel->rel_pages;
    const int   progress_start_index[] = {
        PROGRESS_VACUUM_PHASE,
        PROGRESS_VACUUM_INDEXES_TOTAL
    };
    const int   progress_end_index[] = {
        PROGRESS_VACUUM_INDEXES_TOTAL,
        PROGRESS_VACUUM_INDEXES_PROCESSED
    };
    int64       progress_start_val[2];
    int64       progress_end_val[2] = {0, 0};
 
    Assert(vacrel->do_index_cleanup);
    Assert(vacrel->nindexes > 0);
 
    /*
     * Report that we are now cleaning up indexes and the number of indexes to
     * cleanup.
     */
    progress_start_val[0] = PROGRESS_VACUUM_PHASE_INDEX_CLEANUP;
    progress_start_val[1] = vacrel->nindexes;
    pgstat_progress_update_multi_param(2, progress_start_index, progress_start_val);
 
    if (!ParallelVacuumIsActive(vacrel))
    {
        for (int idx = 0; idx < vacrel->nindexes; idx++)
        {
            Relation    indrel = vacrel->indrels[idx];
            IndexBulkDeleteResult *istat = vacrel->indstats[idx];
 
            vacrel->indstats[idx] =
                lazy_cleanup_one_index(indrel, istat, reltuples,
                                       estimated_count, vacrel);
 
            /* Report the number of indexes cleaned up */
            pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
                                         idx + 1);
        }
    }
    else
    {
        /* Outsource everything to parallel variant */
        parallel_vacuum_cleanup_all_indexes(vacrel->pvs, reltuples,
                                            vacrel->num_index_scans,
                                            estimated_count);
    }
 
    /* Reset the progress counters */
    pgstat_progress_update_multi_param(2, progress_end_index, progress_end_val);
}

References Assert(), LVRelState::do_index_cleanup, idx(), LVRelState::indrels, LVRelState::indstats, lazy_cleanup_one_index(), LVRelState::new_rel_tuples, LVRelState::nindexes, LVRelState::num_index_scans, parallel_vacuum_cleanup_all_indexes(), ParallelVacuumIsActive, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_VACUUM_INDEXES_PROCESSED, PROGRESS_VACUUM_INDEXES_TOTAL, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_INDEX_CLEANUP, LVRelState::pvs, LVRelState::rel_pages, and LVRelState::scanned_pages.

Referenced by lazy_scan_heap().

lazy_cleanup_one_index()

static IndexBulkDeleteResult * lazy_cleanup_one_index ( Relation  indrel, IndexBulkDeleteResult *  istat, double  reltuples, bool  estimated_count, LVRelState *  vacrel  )

static

Definition at line 3178 of file vacuumlazy.c.

{
    IndexVacuumInfo ivinfo;
    LVSavedErrInfo saved_err_info;
 
    ivinfo.index = indrel;
    ivinfo.heaprel = vacrel->rel;
    ivinfo.analyze_only = false;
    ivinfo.report_progress = false;
    ivinfo.estimated_count = estimated_count;
    ivinfo.message_level = DEBUG2;
 
    ivinfo.num_heap_tuples = reltuples;
    ivinfo.strategy = vacrel->bstrategy;
 
    /*
     * Update error traceback information.
     *
     * The index name is saved during this phase and restored immediately
     * after this phase.  See vacuum_error_callback.
     */
    Assert(vacrel->indname == NULL);
    vacrel->indname = pstrdup(RelationGetRelationName(indrel));
    update_vacuum_error_info(vacrel, &saved_err_info,
                             VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
                             InvalidBlockNumber, InvalidOffsetNumber);
 
    istat = vac_cleanup_one_index(&ivinfo, istat);
 
    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrel, &saved_err_info);
    pfree(vacrel->indname);
    vacrel->indname = NULL;
 
    return istat;
}

References IndexVacuumInfo::analyze_only, Assert(), LVRelState::bstrategy, DEBUG2, IndexVacuumInfo::estimated_count, IndexVacuumInfo::heaprel, IndexVacuumInfo::index, LVRelState::indname, InvalidBlockNumber, InvalidOffsetNumber, IndexVacuumInfo::message_level, IndexVacuumInfo::num_heap_tuples, pfree(), pstrdup(), LVRelState::rel, RelationGetRelationName, IndexVacuumInfo::report_progress, restore_vacuum_error_info(), IndexVacuumInfo::strategy, update_vacuum_error_info(), vac_cleanup_one_index(), and VACUUM_ERRCB_PHASE_INDEX_CLEANUP.

Referenced by lazy_cleanup_all_indexes().

lazy_scan_heap()

static void lazy_scan_heap ( LVRelState *  vacrel )

static

Definition at line 1227 of file vacuumlazy.c.

{
    ReadStream *stream;
    BlockNumber rel_pages = vacrel->rel_pages,
                blkno = 0,
                next_fsm_block_to_vacuum = 0;
    BlockNumber orig_eager_scan_success_limit =
        vacrel->eager_scan_remaining_successes; /* for logging */
    Buffer      vmbuffer = InvalidBuffer;
    const int   initprog_index[] = {
        PROGRESS_VACUUM_PHASE,
        PROGRESS_VACUUM_TOTAL_HEAP_BLKS,
        PROGRESS_VACUUM_MAX_DEAD_TUPLE_BYTES
    };
    int64       initprog_val[3];
 
    /* Report that we're scanning the heap, advertising total # of blocks */
    initprog_val[0] = PROGRESS_VACUUM_PHASE_SCAN_HEAP;
    initprog_val[1] = rel_pages;
    initprog_val[2] = vacrel->dead_items_info->max_bytes;
    pgstat_progress_update_multi_param(3, initprog_index, initprog_val);
 
    /* Initialize for the first heap_vac_scan_next_block() call */
    vacrel->current_block = InvalidBlockNumber;
    vacrel->next_unskippable_block = InvalidBlockNumber;
    vacrel->next_unskippable_allvis = false;
    vacrel->next_unskippable_eager_scanned = false;
    vacrel->next_unskippable_vmbuffer = InvalidBuffer;
 
    /*
     * Set up the read stream for vacuum's first pass through the heap.
     *
     * This could be made safe for READ_STREAM_USE_BATCHING, but only with
     * explicit work in heap_vac_scan_next_block.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE,
                                        vacrel->bstrategy,
                                        vacrel->rel,
                                        MAIN_FORKNUM,
                                        heap_vac_scan_next_block,
                                        vacrel,
                                        sizeof(uint8));
 
    while (true)
    {
        Buffer      buf;
        Page        page;
        uint8       blk_info = 0;
        int         ndeleted = 0;
        bool        has_lpdead_items;
        void       *per_buffer_data = NULL;
        bool        vm_page_frozen = false;
        bool        got_cleanup_lock = false;
 
        vacuum_delay_point(false);
 
        /*
         * Regularly check if wraparound failsafe should trigger.
         *
         * There is a similar check inside lazy_vacuum_all_indexes(), but
         * relfrozenxid might start to look dangerously old before we reach
         * that point.  This check also provides failsafe coverage for the
         * one-pass strategy, and the two-pass strategy with the index_cleanup
         * param set to 'off'.
         */
        if (vacrel->scanned_pages > 0 &&
            vacrel->scanned_pages % FAILSAFE_EVERY_PAGES == 0)
            lazy_check_wraparound_failsafe(vacrel);
 
        /*
         * Consider if we definitely have enough space to process TIDs on page
         * already.  If we are close to overrunning the available space for
         * dead_items TIDs, pause and do a cycle of vacuuming before we tackle
         * this page. However, let's force at least one page-worth of tuples
         * to be stored as to ensure we do at least some work when the memory
         * configured is so low that we run out before storing anything.
         */
        if (vacrel->dead_items_info->num_items > 0 &&
            TidStoreMemoryUsage(vacrel->dead_items) > vacrel->dead_items_info->max_bytes)
        {
            /*
             * 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;
            }
 
            /* Perform a round of index and heap vacuuming */
            vacrel->consider_bypass_optimization = false;
            lazy_vacuum(vacrel);
 
            /*
             * Vacuum the Free Space Map to make newly-freed space visible on
             * upper-level FSM pages. Note that blkno is the previously
             * processed block.
             */
            FreeSpaceMapVacuumRange(vacrel->rel, next_fsm_block_to_vacuum,
                                    blkno + 1);
            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);
        }
 
        buf = read_stream_next_buffer(stream, &per_buffer_data);
 
        /* The relation is exhausted. */
        if (!BufferIsValid(buf))
            break;
 
        blk_info = *((uint8 *) per_buffer_data);
        CheckBufferIsPinnedOnce(buf);
        page = BufferGetPage(buf);
        blkno = BufferGetBlockNumber(buf);
 
        vacrel->scanned_pages++;
        if (blk_info & VAC_BLK_WAS_EAGER_SCANNED)
            vacrel->eager_scanned_pages++;
 
        /* Report as block scanned, update error traceback information */
        pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED, blkno);
        update_vacuum_error_info(vacrel, NULL, VACUUM_ERRCB_PHASE_SCAN_HEAP,
                                 blkno, InvalidOffsetNumber);
 
        /*
         * 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.
         */
        visibilitymap_pin(vacrel->rel, blkno, &vmbuffer);
 
        /*
         * We need a buffer cleanup lock to prune HOT chains and defragment
         * the page in lazy_scan_prune.  But when it's not possible to acquire
         * a cleanup lock right away, we may be able to settle for reduced
         * processing using lazy_scan_noprune.
         */
        got_cleanup_lock = ConditionalLockBufferForCleanup(buf);
 
        if (!got_cleanup_lock)
            LockBuffer(buf, BUFFER_LOCK_SHARE);
 
        /* Check for new or empty pages before lazy_scan_[no]prune call */
        if (lazy_scan_new_or_empty(vacrel, buf, blkno, page, !got_cleanup_lock,
                                   vmbuffer))
        {
            /* Processed as new/empty page (lock and pin released) */
            continue;
        }
 
        /*
         * If we didn't get the cleanup lock, we can still collect LP_DEAD
         * items in the dead_items area for later vacuuming, count live and
         * recently dead tuples for vacuum logging, and determine if this
         * block could later be truncated. If we encounter any xid/mxids that
         * require advancing the relfrozenxid/relminxid, we'll have to wait
         * for a cleanup lock and call lazy_scan_prune().
         */
        if (!got_cleanup_lock &&
            !lazy_scan_noprune(vacrel, buf, blkno, page, &has_lpdead_items))
        {
            /*
             * lazy_scan_noprune could not do all required processing.  Wait
             * for a cleanup lock, and call lazy_scan_prune in the usual way.
             */
            Assert(vacrel->aggressive);
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
            LockBufferForCleanup(buf);
            got_cleanup_lock = true;
        }
 
        /*
         * If we have a cleanup lock, we must now prune, freeze, and count
         * tuples. We may have acquired the cleanup lock originally, or we may
         * have gone back and acquired it after lazy_scan_noprune() returned
         * false. Either way, the page hasn't been processed yet.
         *
         * Like lazy_scan_noprune(), lazy_scan_prune() will count
         * recently_dead_tuples and live tuples for vacuum logging, determine
         * if the block can later be truncated, and accumulate the details of
         * remaining LP_DEAD line pointers on the page into dead_items. These
         * dead items include those pruned by lazy_scan_prune() as well as
         * line pointers previously marked LP_DEAD.
         */
        if (got_cleanup_lock)
            ndeleted = lazy_scan_prune(vacrel, buf, blkno, page,
                                       vmbuffer,
                                       blk_info & VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM,
                                       &has_lpdead_items, &vm_page_frozen);
 
        /*
         * Count an eagerly scanned page as a failure or a success.
         *
         * Only lazy_scan_prune() freezes pages, so if we didn't get the
         * cleanup lock, we won't have frozen the page. However, we only count
         * pages that were too new to require freezing as eager freeze
         * failures.
         *
         * We could gather more information from lazy_scan_noprune() about
         * whether or not there were tuples with XIDs or MXIDs older than the
         * FreezeLimit or MultiXactCutoff. However, for simplicity, we simply
         * exclude pages skipped due to cleanup lock contention from eager
         * freeze algorithm caps.
         */
        if (got_cleanup_lock &&
            (blk_info & VAC_BLK_WAS_EAGER_SCANNED))
        {
            /* Aggressive vacuums do not eager scan. */
            Assert(!vacrel->aggressive);
 
            if (vm_page_frozen)
            {
                if (vacrel->eager_scan_remaining_successes > 0)
                    vacrel->eager_scan_remaining_successes--;
 
                if (vacrel->eager_scan_remaining_successes == 0)
                {
                    /*
                     * Report only once that we disabled eager scanning. We
                     * may eagerly read ahead blocks in excess of the success
                     * or failure caps before attempting to freeze them, so we
                     * could reach here even after disabling additional eager
                     * scanning.
                     */
                    if (vacrel->eager_scan_max_fails_per_region > 0)
                        ereport(vacrel->verbose ? INFO : DEBUG2,
                                (errmsg("disabling eager scanning after freezing %u eagerly scanned blocks of relation \"%s.%s.%s\"",
                                        orig_eager_scan_success_limit,
                                        vacrel->dbname, vacrel->relnamespace,
                                        vacrel->relname)));
 
                    /*
                     * If we hit our success cap, permanently disable eager
                     * scanning by setting the other eager scan management
                     * fields to their disabled values.
                     */
                    vacrel->eager_scan_remaining_fails = 0;
                    vacrel->next_eager_scan_region_start = InvalidBlockNumber;
                    vacrel->eager_scan_max_fails_per_region = 0;
                }
            }
            else if (vacrel->eager_scan_remaining_fails > 0)
                vacrel->eager_scan_remaining_fails--;
        }
 
        /*
         * Now drop the buffer lock and, potentially, update the FSM.
         *
         * Our goal is to update the freespace map the last time we touch the
         * page. If we'll process a block in the second pass, we may free up
         * additional space on the page, so it is better to update the FSM
         * after the second pass. If the relation has no indexes, or if index
         * vacuuming is disabled, there will be no second heap pass; if this
         * particular page has no dead items, the second heap pass will not
         * touch this page. So, in those cases, update the FSM now.
         *
         * Note: In corner cases, it's possible to miss updating the FSM
         * entirely. If index vacuuming is currently enabled, we'll skip the
         * FSM update now. But if failsafe mode is later activated, or there
         * are so few dead tuples that index vacuuming is bypassed, there will
         * also be no opportunity to update the FSM later, because we'll never
         * revisit this page. Since updating the FSM is desirable but not
         * absolutely required, that's OK.
         */
        if (vacrel->nindexes == 0
            || !vacrel->do_index_vacuuming
            || !has_lpdead_items)
        {
            Size        freespace = PageGetHeapFreeSpace(page);
 
            UnlockReleaseBuffer(buf);
            RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
 
            /*
             * Periodically perform FSM vacuuming to make newly-freed space
             * visible on upper FSM pages. This is done after vacuuming if the
             * table has indexes. There will only be newly-freed space if we
             * held the cleanup lock and lazy_scan_prune() was called.
             */
            if (got_cleanup_lock && vacrel->nindexes == 0 && ndeleted > 0 &&
                blkno - next_fsm_block_to_vacuum >= VACUUM_FSM_EVERY_PAGES)
            {
                FreeSpaceMapVacuumRange(vacrel->rel, next_fsm_block_to_vacuum,
                                        blkno);
                next_fsm_block_to_vacuum = blkno;
            }
        }
        else
            UnlockReleaseBuffer(buf);
    }
 
    vacrel->blkno = InvalidBlockNumber;
    if (BufferIsValid(vmbuffer))
        ReleaseBuffer(vmbuffer);
 
    /*
     * Report that everything is now scanned. We never skip scanning the last
     * block in the relation, so we can pass rel_pages here.
     */
    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_SCANNED,
                                 rel_pages);
 
    /* now we can compute the new value for pg_class.reltuples */
    vacrel->new_live_tuples = vac_estimate_reltuples(vacrel->rel, rel_pages,
                                                     vacrel->scanned_pages,
                                                     vacrel->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.
     */
    vacrel->new_rel_tuples =
        Max(vacrel->new_live_tuples, 0) + vacrel->recently_dead_tuples +
        vacrel->missed_dead_tuples;
 
    read_stream_end(stream);
 
    /*
     * Do index vacuuming (call each index's ambulkdelete routine), then do
     * related heap vacuuming
     */
    if (vacrel->dead_items_info->num_items > 0)
        lazy_vacuum(vacrel);
 
    /*
     * Vacuum the remainder of the Free Space Map.  We must do this whether or
     * not there were indexes, and whether or not we bypassed index vacuuming.
     * We can pass rel_pages here because we never skip scanning the last
     * block of the relation.
     */
    if (rel_pages > next_fsm_block_to_vacuum)
        FreeSpaceMapVacuumRange(vacrel->rel, next_fsm_block_to_vacuum, rel_pages);
 
    /* report all blocks vacuumed */
    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, rel_pages);
 
    /* Do final index cleanup (call each index's amvacuumcleanup routine) */
    if (vacrel->nindexes > 0 && vacrel->do_index_cleanup)
        lazy_cleanup_all_indexes(vacrel);
}

References LVRelState::aggressive, Assert(), LVRelState::blkno, LVRelState::bstrategy, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), CheckBufferIsPinnedOnce(), ConditionalLockBufferForCleanup(), LVRelState::consider_bypass_optimization, LVRelState::current_block, LVRelState::dbname, LVRelState::dead_items, LVRelState::dead_items_info, DEBUG2, LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, LVRelState::eager_scan_max_fails_per_region, LVRelState::eager_scan_remaining_fails, LVRelState::eager_scan_remaining_successes, LVRelState::eager_scanned_pages, ereport, errmsg(), FAILSAFE_EVERY_PAGES, FreeSpaceMapVacuumRange(), heap_vac_scan_next_block(), INFO, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, lazy_check_wraparound_failsafe(), lazy_cleanup_all_indexes(), lazy_scan_new_or_empty(), lazy_scan_noprune(), lazy_scan_prune(), lazy_vacuum(), LVRelState::live_tuples, LockBuffer(), LockBufferForCleanup(), MAIN_FORKNUM, Max, VacDeadItemsInfo::max_bytes, LVRelState::missed_dead_tuples, LVRelState::new_live_tuples, LVRelState::new_rel_tuples, LVRelState::next_eager_scan_region_start, LVRelState::next_unskippable_allvis, LVRelState::next_unskippable_block, LVRelState::next_unskippable_eager_scanned, LVRelState::next_unskippable_vmbuffer, LVRelState::nindexes, VacDeadItemsInfo::num_items, PageGetHeapFreeSpace(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_VACUUM_HEAP_BLKS_SCANNED, PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, PROGRESS_VACUUM_MAX_DEAD_TUPLE_BYTES, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_SCAN_HEAP, PROGRESS_VACUUM_TOTAL_HEAP_BLKS, read_stream_begin_relation(), read_stream_end(), READ_STREAM_MAINTENANCE, read_stream_next_buffer(), LVRelState::recently_dead_tuples, RecordPageWithFreeSpace(), LVRelState::rel, LVRelState::rel_pages, ReleaseBuffer(), LVRelState::relname, LVRelState::relnamespace, LVRelState::scanned_pages, TidStoreMemoryUsage(), UnlockReleaseBuffer(), update_vacuum_error_info(), VAC_BLK_ALL_VISIBLE_ACCORDING_TO_VM, VAC_BLK_WAS_EAGER_SCANNED, vac_estimate_reltuples(), vacuum_delay_point(), VACUUM_ERRCB_PHASE_SCAN_HEAP, VACUUM_FSM_EVERY_PAGES, LVRelState::verbose, and visibilitymap_pin().

Referenced by heap_vacuum_rel().

lazy_scan_new_or_empty()

static bool lazy_scan_new_or_empty ( LVRelState *  vacrel, Buffer  buf, BlockNumber  blkno, Page  page, bool  sharelock, Buffer  vmbuffer  )

static

Definition at line 1836 of file vacuumlazy.c.

{
    Size        freespace;
 
    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), and then 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 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);
 
        if (GetRecordedFreeSpace(vacrel->rel, blkno) == 0)
        {
            freespace = BLCKSZ - SizeOfPageHeaderData;
 
            RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
        }
 
        return true;
    }
 
    if (PageIsEmpty(page))
    {
        /*
         * It seems likely that caller will always be able to get a cleanup
         * lock on an empty page.  But don't take any chances -- escalate to
         * an exclusive lock (still don't need a cleanup lock, though).
         */
        if (sharelock)
        {
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
            LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
 
            if (!PageIsEmpty(page))
            {
                /* page isn't new or empty -- keep lock and pin for now */
                return false;
            }
        }
        else
        {
            /* Already have a full cleanup lock (which is more than enough) */
        }
 
        /*
         * Unlike new pages, empty pages are always set all-visible and
         * all-frozen.
         */
        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(vacrel->rel) &&
                !XLogRecPtrIsValid(PageGetLSN(page)))
                log_newpage_buffer(buf, true);
 
            PageSetAllVisible(page);
            visibilitymap_set(vacrel->rel, blkno, buf,
                              InvalidXLogRecPtr,
                              vmbuffer, InvalidTransactionId,
                              VISIBILITYMAP_ALL_VISIBLE |
                              VISIBILITYMAP_ALL_FROZEN);
            END_CRIT_SECTION();
 
            /* Count the newly all-frozen pages for logging */
            vacrel->vm_new_visible_pages++;
            vacrel->vm_new_visible_frozen_pages++;
        }
 
        freespace = PageGetHeapFreeSpace(page);
        UnlockReleaseBuffer(buf);
        RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
        return true;
    }
 
    /* page isn't new or empty -- keep lock and pin */
    return false;
}

References buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, END_CRIT_SECTION, GetRecordedFreeSpace(), InvalidTransactionId, InvalidXLogRecPtr, LockBuffer(), log_newpage_buffer(), MarkBufferDirty(), PageGetHeapFreeSpace(), PageGetLSN(), PageIsAllVisible(), PageIsEmpty(), PageIsNew(), PageSetAllVisible(), RecordPageWithFreeSpace(), LVRelState::rel, RelationNeedsWAL, SizeOfPageHeaderData, START_CRIT_SECTION, UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_set(), LVRelState::vm_new_visible_frozen_pages, LVRelState::vm_new_visible_pages, and XLogRecPtrIsValid.

Referenced by lazy_scan_heap().

lazy_scan_noprune()

static bool lazy_scan_noprune ( LVRelState *  vacrel, Buffer  buf, BlockNumber  blkno, Page  page, bool *  has_lpdead_items  )

static

Definition at line 2277 of file vacuumlazy.c.

{
    OffsetNumber offnum,
                maxoff;
    int         lpdead_items,
                live_tuples,
                recently_dead_tuples,
                missed_dead_tuples;
    bool        hastup;
    HeapTupleHeader tupleheader;
    TransactionId NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid;
    MultiXactId NoFreezePageRelminMxid = vacrel->NewRelminMxid;
    OffsetNumber deadoffsets[MaxHeapTuplesPerPage];
 
    Assert(BufferGetBlockNumber(buf) == blkno);
 
    hastup = false;             /* for now */
 
    lpdead_items = 0;
    live_tuples = 0;
    recently_dead_tuples = 0;
    missed_dead_tuples = 0;
 
    maxoff = PageGetMaxOffsetNumber(page);
    for (offnum = FirstOffsetNumber;
         offnum <= maxoff;
         offnum = OffsetNumberNext(offnum))
    {
        ItemId      itemid;
        HeapTupleData tuple;
 
        vacrel->offnum = offnum;
        itemid = PageGetItemId(page, offnum);
 
        if (!ItemIdIsUsed(itemid))
            continue;
 
        if (ItemIdIsRedirected(itemid))
        {
            hastup = true;
            continue;
        }
 
        if (ItemIdIsDead(itemid))
        {
            /*
             * Deliberately don't set hastup=true here.  See same point in
             * lazy_scan_prune for an explanation.
             */
            deadoffsets[lpdead_items++] = offnum;
            continue;
        }
 
        hastup = true;          /* page prevents rel truncation */
        tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
        if (heap_tuple_should_freeze(tupleheader, &vacrel->cutoffs,
                                     &NoFreezePageRelfrozenXid,
                                     &NoFreezePageRelminMxid))
        {
            /* Tuple with XID < FreezeLimit (or MXID < MultiXactCutoff) */
            if (vacrel->aggressive)
            {
                /*
                 * Aggressive VACUUMs must always be able to advance rel's
                 * relfrozenxid to a value >= FreezeLimit (and be able to
                 * advance rel's relminmxid to a value >= MultiXactCutoff).
                 * The ongoing aggressive VACUUM won't be able to do that
                 * unless it can freeze an XID (or MXID) from this tuple now.
                 *
                 * The only safe option is to have caller perform processing
                 * of this page using lazy_scan_prune.  Caller might have to
                 * wait a while for a cleanup lock, but it can't be helped.
                 */
                vacrel->offnum = InvalidOffsetNumber;
                return false;
            }
 
            /*
             * Non-aggressive VACUUMs are under no obligation to advance
             * relfrozenxid (even by one XID).  We can be much laxer here.
             *
             * Currently we always just accept an older final relfrozenxid
             * and/or relminmxid value.  We never make caller wait or work a
             * little harder, even when it likely makes sense to do so.
             */
        }
 
        ItemPointerSet(&(tuple.t_self), blkno, offnum);
        tuple.t_data = (HeapTupleHeader) PageGetItem(page, itemid);
        tuple.t_len = ItemIdGetLength(itemid);
        tuple.t_tableOid = RelationGetRelid(vacrel->rel);
 
        switch (HeapTupleSatisfiesVacuum(&tuple, vacrel->cutoffs.OldestXmin,
                                         buf))
        {
            case HEAPTUPLE_DELETE_IN_PROGRESS:
            case HEAPTUPLE_LIVE:
 
                /*
                 * Count both cases as live, just like lazy_scan_prune
                 */
                live_tuples++;
 
                break;
            case HEAPTUPLE_DEAD:
 
                /*
                 * There is some useful work for pruning to do, that won't be
                 * done due to failure to get a cleanup lock.
                 */
                missed_dead_tuples++;
                break;
            case HEAPTUPLE_RECENTLY_DEAD:
 
                /*
                 * Count in recently_dead_tuples, just like lazy_scan_prune
                 */
                recently_dead_tuples++;
                break;
            case HEAPTUPLE_INSERT_IN_PROGRESS:
 
                /*
                 * Do not count these rows as live, just like lazy_scan_prune
                 */
                break;
            default:
                elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                break;
        }
    }
 
    vacrel->offnum = InvalidOffsetNumber;
 
    /*
     * By here we know for sure that caller can put off freezing and pruning
     * this particular page until the next VACUUM.  Remember its details now.
     * (lazy_scan_prune expects a clean slate, so we have to do this last.)
     */
    vacrel->NewRelfrozenXid = NoFreezePageRelfrozenXid;
    vacrel->NewRelminMxid = NoFreezePageRelminMxid;
 
    /* Save any LP_DEAD items found on the page in dead_items */
    if (vacrel->nindexes == 0)
    {
        /* Using one-pass strategy (since table has no indexes) */
        if (lpdead_items > 0)
        {
            /*
             * Perfunctory handling for the corner case where a single pass
             * strategy VACUUM cannot get a cleanup lock, and it turns out
             * that there is one or more LP_DEAD items: just count the LP_DEAD
             * items as missed_dead_tuples instead. (This is a bit dishonest,
             * but it beats having to maintain specialized heap vacuuming code
             * forever, for vanishingly little benefit.)
             */
            hastup = true;
            missed_dead_tuples += lpdead_items;
        }
    }
    else if (lpdead_items > 0)
    {
        /*
         * Page has LP_DEAD items, and so any references/TIDs that remain in
         * indexes will be deleted during index vacuuming (and then marked
         * LP_UNUSED in the heap)
         */
        vacrel->lpdead_item_pages++;
 
        dead_items_add(vacrel, blkno, deadoffsets, lpdead_items);
 
        vacrel->lpdead_items += lpdead_items;
    }
 
    /*
     * Finally, add relevant page-local counts to whole-VACUUM counts
     */
    vacrel->live_tuples += live_tuples;
    vacrel->recently_dead_tuples += recently_dead_tuples;
    vacrel->missed_dead_tuples += missed_dead_tuples;
    if (missed_dead_tuples > 0)
        vacrel->missed_dead_pages++;
 
    /* Can't truncate this page */
    if (hastup)
        vacrel->nonempty_pages = blkno + 1;
 
    /* Did we find LP_DEAD items? */
    *has_lpdead_items = (lpdead_items > 0);
 
    /* Caller won't need to call lazy_scan_prune with same page */
    return true;
}

References LVRelState::aggressive, Assert(), buf, BufferGetBlockNumber(), LVRelState::cutoffs, dead_items_add(), elog, ERROR, FirstOffsetNumber, heap_tuple_should_freeze(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleSatisfiesVacuum(), InvalidOffsetNumber, ItemIdGetLength, ItemIdIsDead, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), LVRelState::live_tuples, LVRelState::lpdead_item_pages, LVRelState::lpdead_items, MaxHeapTuplesPerPage, LVRelState::missed_dead_pages, LVRelState::missed_dead_tuples, LVRelState::NewRelfrozenXid, LVRelState::NewRelminMxid, LVRelState::nindexes, LVRelState::nonempty_pages, LVRelState::offnum, OffsetNumberNext, VacuumCutoffs::OldestXmin, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), LVRelState::recently_dead_tuples, LVRelState::rel, RelationGetRelid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by lazy_scan_heap().

lazy_scan_prune()

static int lazy_scan_prune ( LVRelState *  vacrel, Buffer  buf, BlockNumber  blkno, Page  page, Buffer  vmbuffer, bool  all_visible_according_to_vm, bool *  has_lpdead_items, bool *  vm_page_frozen  )

static

Definition at line 1971 of file vacuumlazy.c.

{
    Relation    rel = vacrel->rel;
    PruneFreezeResult presult;
    PruneFreezeParams params = {
        .relation = rel,
        .buffer = buf,
        .reason = PRUNE_VACUUM_SCAN,
        .options = HEAP_PAGE_PRUNE_FREEZE,
        .vistest = vacrel->vistest,
        .cutoffs = &vacrel->cutoffs,
    };
 
    Assert(BufferGetBlockNumber(buf) == blkno);
 
    /*
     * Prune all HOT-update chains and potentially freeze tuples on this page.
     *
     * If the relation has no indexes, we can immediately mark would-be dead
     * items LP_UNUSED.
     *
     * The number of tuples removed from the page is returned in
     * presult.ndeleted.  It should not be confused with presult.lpdead_items;
     * presult.lpdead_items's final value can be thought of as the number of
     * tuples that were deleted from indexes.
     *
     * We will update the VM after collecting LP_DEAD items and freezing
     * tuples. Pruning will have determined whether or not the page is
     * all-visible.
     */
    if (vacrel->nindexes == 0)
        params.options |= HEAP_PAGE_PRUNE_MARK_UNUSED_NOW;
 
    heap_page_prune_and_freeze(&params,
                               &presult,
                               &vacrel->offnum,
                               &vacrel->NewRelfrozenXid, &vacrel->NewRelminMxid);
 
    Assert(MultiXactIdIsValid(vacrel->NewRelminMxid));
    Assert(TransactionIdIsValid(vacrel->NewRelfrozenXid));
 
    if (presult.nfrozen > 0)
    {
        /*
         * We don't increment the new_frozen_tuple_pages instrumentation
         * counter when nfrozen == 0, since it only counts pages with newly
         * frozen tuples (don't confuse that with pages newly set all-frozen
         * in VM).
         */
        vacrel->new_frozen_tuple_pages++;
    }
 
    /*
     * VACUUM will call heap_page_is_all_visible() during the second pass over
     * the heap to determine all_visible and all_frozen for the page -- this
     * is a specialized version of the logic from this function.  Now that
     * we've finished pruning and freezing, make sure that we're in total
     * agreement with heap_page_is_all_visible() using an assertion.
     */
#ifdef USE_ASSERT_CHECKING
    if (presult.all_visible)
    {
        TransactionId debug_cutoff;
        bool        debug_all_frozen;
 
        Assert(presult.lpdead_items == 0);
 
        Assert(heap_page_is_all_visible(vacrel->rel, buf,
                                        vacrel->cutoffs.OldestXmin, &debug_all_frozen,
                                        &debug_cutoff, &vacrel->offnum));
 
        Assert(presult.all_frozen == debug_all_frozen);
 
        Assert(!TransactionIdIsValid(debug_cutoff) ||
               debug_cutoff == presult.vm_conflict_horizon);
    }
#endif
 
    /*
     * Now save details of the LP_DEAD items from the page in vacrel
     */
    if (presult.lpdead_items > 0)
    {
        vacrel->lpdead_item_pages++;
 
        /*
         * deadoffsets are collected incrementally in
         * heap_page_prune_and_freeze() as each dead line pointer is recorded,
         * with an indeterminate order, but dead_items_add requires them to be
         * sorted.
         */
        qsort(presult.deadoffsets, presult.lpdead_items, sizeof(OffsetNumber),
              cmpOffsetNumbers);
 
        dead_items_add(vacrel, blkno, presult.deadoffsets, presult.lpdead_items);
    }
 
    /* Finally, add page-local counts to whole-VACUUM counts */
    vacrel->tuples_deleted += presult.ndeleted;
    vacrel->tuples_frozen += presult.nfrozen;
    vacrel->lpdead_items += presult.lpdead_items;
    vacrel->live_tuples += presult.live_tuples;
    vacrel->recently_dead_tuples += presult.recently_dead_tuples;
 
    /* Can't truncate this page */
    if (presult.hastup)
        vacrel->nonempty_pages = blkno + 1;
 
    /* Did we find LP_DEAD items? */
    *has_lpdead_items = (presult.lpdead_items > 0);
 
    Assert(!presult.all_visible || !(*has_lpdead_items));
    Assert(!presult.all_frozen || presult.all_visible);
 
    /*
     * Handle setting visibility map bit based on information from the VM (as
     * of last heap_vac_scan_next_block() call), and from all_visible and
     * all_frozen variables
     */
    if (!all_visible_according_to_vm && presult.all_visible)
    {
        uint8       old_vmbits;
        uint8       flags = VISIBILITYMAP_ALL_VISIBLE;
 
        if (presult.all_frozen)
        {
            Assert(!TransactionIdIsValid(presult.vm_conflict_horizon));
            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);
        old_vmbits = visibilitymap_set(vacrel->rel, blkno, buf,
                                       InvalidXLogRecPtr,
                                       vmbuffer, presult.vm_conflict_horizon,
                                       flags);
 
        /*
         * If the page wasn't already set all-visible and/or all-frozen in the
         * VM, count it as newly set for logging.
         */
        if ((old_vmbits & VISIBILITYMAP_ALL_VISIBLE) == 0)
        {
            vacrel->vm_new_visible_pages++;
            if (presult.all_frozen)
            {
                vacrel->vm_new_visible_frozen_pages++;
                *vm_page_frozen = true;
            }
        }
        else if ((old_vmbits & VISIBILITYMAP_ALL_FROZEN) == 0 &&
                 presult.all_frozen)
        {
            vacrel->vm_new_frozen_pages++;
            *vm_page_frozen = true;
        }
    }
 
    /*
     * 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 heap_vac_scan_next_block() was called, so we must recheck
     * with buffer lock before concluding that the VM is corrupt.
     */
    else if (all_visible_according_to_vm && !PageIsAllVisible(page) &&
             visibilitymap_get_status(vacrel->rel, blkno, &vmbuffer) != 0)
    {
        ereport(WARNING,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
                        vacrel->relname, blkno)));
 
        visibilitymap_clear(vacrel->rel, 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 LP_DEAD items on a page with PD_ALL_VISIBLE set,
     * however.
     */
    else if (presult.lpdead_items > 0 && PageIsAllVisible(page))
    {
        ereport(WARNING,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg("page containing LP_DEAD items is marked as all-visible in relation \"%s\" page %u",
                        vacrel->relname, blkno)));
 
        PageClearAllVisible(page);
        MarkBufferDirty(buf);
        visibilitymap_clear(vacrel->rel, blkno, vmbuffer,
                            VISIBILITYMAP_VALID_BITS);
    }
 
    /*
     * If the all-visible page is all-frozen but not marked as such yet, mark
     * it as all-frozen.
     */
    else if (all_visible_according_to_vm && presult.all_frozen &&
             !VM_ALL_FROZEN(vacrel->rel, blkno, &vmbuffer))
    {
        uint8       old_vmbits;
 
        /*
         * Avoid relying on all_visible_according_to_vm as a proxy for the
         * page-level PD_ALL_VISIBLE bit being set, since it might have become
         * stale -- even when all_visible is set
         */
        if (!PageIsAllVisible(page))
        {
            PageSetAllVisible(page);
            MarkBufferDirty(buf);
        }
 
        /*
         * Set the page all-frozen (and all-visible) in the VM.
         *
         * We can pass InvalidTransactionId as our cutoff_xid, since a
         * snapshotConflictHorizon sufficient to make everything safe for REDO
         * was logged when the page's tuples were frozen.
         */
        Assert(!TransactionIdIsValid(presult.vm_conflict_horizon));
        old_vmbits = visibilitymap_set(vacrel->rel, blkno, buf,
                                       InvalidXLogRecPtr,
                                       vmbuffer, InvalidTransactionId,
                                       VISIBILITYMAP_ALL_VISIBLE |
                                       VISIBILITYMAP_ALL_FROZEN);
 
        /*
         * The page was likely already set all-visible in the VM. However,
         * there is a small chance that it was modified sometime between
         * setting all_visible_according_to_vm and checking the visibility
         * during pruning. Check the return value of old_vmbits anyway to
         * ensure the visibility map counters used for logging are accurate.
         */
        if ((old_vmbits & VISIBILITYMAP_ALL_VISIBLE) == 0)
        {
            vacrel->vm_new_visible_pages++;
            vacrel->vm_new_visible_frozen_pages++;
            *vm_page_frozen = true;
        }
 
        /*
         * We already checked that the page was not set all-frozen in the VM
         * above, so we don't need to test the value of old_vmbits.
         */
        else
        {
            vacrel->vm_new_frozen_pages++;
            *vm_page_frozen = true;
        }
    }
 
    return presult.ndeleted;
}

References PruneFreezeResult::all_frozen, PruneFreezeResult::all_visible, Assert(), buf, BufferGetBlockNumber(), cmpOffsetNumbers(), LVRelState::cutoffs, dead_items_add(), PruneFreezeResult::deadoffsets, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), PruneFreezeResult::hastup, heap_page_prune_and_freeze(), HEAP_PAGE_PRUNE_FREEZE, HEAP_PAGE_PRUNE_MARK_UNUSED_NOW, InvalidTransactionId, InvalidXLogRecPtr, LVRelState::live_tuples, PruneFreezeResult::live_tuples, LVRelState::lpdead_item_pages, LVRelState::lpdead_items, PruneFreezeResult::lpdead_items, MarkBufferDirty(), MultiXactIdIsValid, PruneFreezeResult::ndeleted, LVRelState::new_frozen_tuple_pages, LVRelState::NewRelfrozenXid, LVRelState::NewRelminMxid, PruneFreezeResult::nfrozen, LVRelState::nindexes, LVRelState::nonempty_pages, LVRelState::offnum, VacuumCutoffs::OldestXmin, PruneFreezeParams::options, PageClearAllVisible(), PageIsAllVisible(), PageSetAllVisible(), PRUNE_VACUUM_SCAN, qsort, LVRelState::recently_dead_tuples, PruneFreezeResult::recently_dead_tuples, LVRelState::rel, PruneFreezeParams::relation, LVRelState::relname, TransactionIdIsValid, LVRelState::tuples_deleted, LVRelState::tuples_frozen, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_clear(), visibilitymap_get_status(), visibilitymap_set(), VISIBILITYMAP_VALID_BITS, LVRelState::vistest, VM_ALL_FROZEN, PruneFreezeResult::vm_conflict_horizon, LVRelState::vm_new_frozen_pages, LVRelState::vm_new_visible_frozen_pages, LVRelState::vm_new_visible_pages, and WARNING.

Referenced by lazy_scan_heap().

lazy_truncate_heap()

static void lazy_truncate_heap ( LVRelState *  vacrel )

static

Definition at line 3258 of file vacuumlazy.c.

{
    BlockNumber orig_rel_pages = vacrel->rel_pages;
    BlockNumber new_rel_pages;
    bool        lock_waiter_detected;
    int         lock_retry;
 
    /* Report that we are now truncating */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_TRUNCATE);
 
    /* Update error traceback information one last time */
    update_vacuum_error_info(vacrel, NULL, VACUUM_ERRCB_PHASE_TRUNCATE,
                             vacrel->nonempty_pages, InvalidOffsetNumber);
 
    /*
     * Loop until no more truncating can be done.
     */
    do
    {
        /*
         * 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).
         */
        lock_waiter_detected = false;
        lock_retry = 0;
        while (true)
        {
            if (ConditionalLockRelation(vacrel->rel, 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.
                 */
                ereport(vacrel->verbose ? INFO : DEBUG2,
                        (errmsg("\"%s\": stopping truncate due to conflicting lock request",
                                vacrel->relname)));
                return;
            }
 
            (void) WaitLatch(MyLatch,
                             WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH,
                             VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL,
                             WAIT_EVENT_VACUUM_TRUNCATE);
            ResetLatch(MyLatch);
        }
 
        /*
         * 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(vacrel->rel);
        if (new_rel_pages != orig_rel_pages)
        {
            /*
             * Note: we intentionally don't update vacrel->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(vacrel->rel, 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(vacrel, &lock_waiter_detected);
        vacrel->blkno = new_rel_pages;
 
        if (new_rel_pages >= orig_rel_pages)
        {
            /* can't do anything after all */
            UnlockRelation(vacrel->rel, AccessExclusiveLock);
            return;
        }
 
        /*
         * Okay to truncate.
         */
        RelationTruncate(vacrel->rel, 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(vacrel->rel, 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.
         */
        vacrel->removed_pages += orig_rel_pages - new_rel_pages;
        vacrel->rel_pages = new_rel_pages;
 
        ereport(vacrel->verbose ? INFO : DEBUG2,
                (errmsg("table \"%s\": truncated %u to %u pages",
                        vacrel->relname,
                        orig_rel_pages, new_rel_pages)));
        orig_rel_pages = new_rel_pages;
    } while (new_rel_pages > vacrel->nonempty_pages && lock_waiter_detected);
}

References AccessExclusiveLock, LVRelState::blkno, CHECK_FOR_INTERRUPTS, ConditionalLockRelation(), count_nondeletable_pages(), DEBUG2, ereport, errmsg(), INFO, InvalidOffsetNumber, MyLatch, LVRelState::nonempty_pages, pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_TRUNCATE, LVRelState::rel, LVRelState::rel_pages, RelationGetNumberOfBlocks, RelationTruncate(), LVRelState::relname, LVRelState::removed_pages, ResetLatch(), UnlockRelation(), update_vacuum_error_info(), VACUUM_ERRCB_PHASE_TRUNCATE, VACUUM_TRUNCATE_LOCK_TIMEOUT, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, LVRelState::verbose, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.

Referenced by heap_vacuum_rel().

lazy_vacuum()

static void lazy_vacuum ( LVRelState *  vacrel )

static

Definition at line 2488 of file vacuumlazy.c.

{
    bool        bypass;
 
    /* Should not end up here with no indexes */
    Assert(vacrel->nindexes > 0);
    Assert(vacrel->lpdead_item_pages > 0);
 
    if (!vacrel->do_index_vacuuming)
    {
        Assert(!vacrel->do_index_cleanup);
        dead_items_reset(vacrel);
        return;
    }
 
    /*
     * Consider bypassing index vacuuming (and heap vacuuming) entirely.
     *
     * We currently only do this in cases where the number of LP_DEAD items
     * for the entire VACUUM operation is close to zero.  This avoids sharp
     * discontinuities in the duration and overhead of successive VACUUM
     * operations that run against the same table with a fixed workload.
     * Ideally, successive VACUUM operations will behave as if there are
     * exactly zero LP_DEAD items in cases where there are close to zero.
     *
     * This is likely to be helpful with a table that is continually affected
     * by UPDATEs that can mostly apply the HOT optimization, but occasionally
     * have small aberrations that lead to just a few heap pages retaining
     * only one or two LP_DEAD items.  This is pretty common; even when the
     * DBA goes out of their way to make UPDATEs use HOT, it is practically
     * impossible to predict whether HOT will be applied in 100% of cases.
     * It's far easier to ensure that 99%+ of all UPDATEs against a table use
     * HOT through careful tuning.
     */
    bypass = false;
    if (vacrel->consider_bypass_optimization && vacrel->rel_pages > 0)
    {
        BlockNumber threshold;
 
        Assert(vacrel->num_index_scans == 0);
        Assert(vacrel->lpdead_items == vacrel->dead_items_info->num_items);
        Assert(vacrel->do_index_vacuuming);
        Assert(vacrel->do_index_cleanup);
 
        /*
         * This crossover point at which we'll start to do index vacuuming is
         * expressed as a percentage of the total number of heap pages in the
         * table that are known to have at least one LP_DEAD item.  This is
         * much more important than the total number of LP_DEAD items, since
         * it's a proxy for the number of heap pages whose visibility map bits
         * cannot be set on account of bypassing index and heap vacuuming.
         *
         * We apply one further precautionary test: the space currently used
         * to store the TIDs (TIDs that now all point to LP_DEAD items) must
         * not exceed 32MB.  This limits the risk that we will bypass index
         * vacuuming again and again until eventually there is a VACUUM whose
         * dead_items space is not CPU cache resident.
         *
         * We don't take any special steps to remember the LP_DEAD items (such
         * as counting them in our final update to the stats system) when the
         * optimization is applied.  Though the accounting used in analyze.c's
         * acquire_sample_rows() will recognize the same LP_DEAD items as dead
         * rows in its own stats report, that's okay. The discrepancy should
         * be negligible.  If this optimization is ever expanded to cover more
         * cases then this may need to be reconsidered.
         */
        threshold = (double) vacrel->rel_pages * BYPASS_THRESHOLD_PAGES;
        bypass = (vacrel->lpdead_item_pages < threshold &&
                  TidStoreMemoryUsage(vacrel->dead_items) < 32 * 1024 * 1024);
    }
 
    if (bypass)
    {
        /*
         * There are almost zero TIDs.  Behave as if there were precisely
         * zero: bypass index vacuuming, but do index cleanup.
         *
         * We expect that the ongoing VACUUM operation will finish very
         * quickly, so there is no point in considering speeding up as a
         * failsafe against wraparound failure. (Index cleanup is expected to
         * finish very quickly in cases where there were no ambulkdelete()
         * calls.)
         */
        vacrel->do_index_vacuuming = false;
    }
    else if (lazy_vacuum_all_indexes(vacrel))
    {
        /*
         * We successfully completed a round of index vacuuming.  Do related
         * heap vacuuming now.
         */
        lazy_vacuum_heap_rel(vacrel);
    }
    else
    {
        /*
         * Failsafe case.
         *
         * We attempted index vacuuming, but didn't finish a full round/full
         * index scan.  This happens when relfrozenxid or relminmxid is too
         * far in the past.
         *
         * From this point on the VACUUM operation will do no further index
         * vacuuming or heap vacuuming.  This VACUUM operation won't end up
         * back here again.
         */
        Assert(VacuumFailsafeActive);
    }
 
    /*
     * Forget the LP_DEAD items that we just vacuumed (or just decided to not
     * vacuum)
     */
    dead_items_reset(vacrel);
}

References Assert(), BYPASS_THRESHOLD_PAGES, LVRelState::consider_bypass_optimization, LVRelState::dead_items, LVRelState::dead_items_info, dead_items_reset(), LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, lazy_vacuum_all_indexes(), lazy_vacuum_heap_rel(), LVRelState::lpdead_item_pages, LVRelState::lpdead_items, LVRelState::nindexes, LVRelState::num_index_scans, VacDeadItemsInfo::num_items, LVRelState::rel_pages, TidStoreMemoryUsage(), and VacuumFailsafeActive.

Referenced by lazy_scan_heap().

lazy_vacuum_all_indexes()

static bool lazy_vacuum_all_indexes ( LVRelState *  vacrel )

static

Definition at line 2613 of file vacuumlazy.c.

{
    bool        allindexes = true;
    double      old_live_tuples = vacrel->rel->rd_rel->reltuples;
    const int   progress_start_index[] = {
        PROGRESS_VACUUM_PHASE,
        PROGRESS_VACUUM_INDEXES_TOTAL
    };
    const int   progress_end_index[] = {
        PROGRESS_VACUUM_INDEXES_TOTAL,
        PROGRESS_VACUUM_INDEXES_PROCESSED,
        PROGRESS_VACUUM_NUM_INDEX_VACUUMS
    };
    int64       progress_start_val[2];
    int64       progress_end_val[3];
 
    Assert(vacrel->nindexes > 0);
    Assert(vacrel->do_index_vacuuming);
    Assert(vacrel->do_index_cleanup);
 
    /* Precheck for XID wraparound emergencies */
    if (lazy_check_wraparound_failsafe(vacrel))
    {
        /* Wraparound emergency -- don't even start an index scan */
        return false;
    }
 
    /*
     * Report that we are now vacuuming indexes and the number of indexes to
     * vacuum.
     */
    progress_start_val[0] = PROGRESS_VACUUM_PHASE_VACUUM_INDEX;
    progress_start_val[1] = vacrel->nindexes;
    pgstat_progress_update_multi_param(2, progress_start_index, progress_start_val);
 
    if (!ParallelVacuumIsActive(vacrel))
    {
        for (int idx = 0; idx < vacrel->nindexes; idx++)
        {
            Relation    indrel = vacrel->indrels[idx];
            IndexBulkDeleteResult *istat = vacrel->indstats[idx];
 
            vacrel->indstats[idx] = lazy_vacuum_one_index(indrel, istat,
                                                          old_live_tuples,
                                                          vacrel);
 
            /* Report the number of indexes vacuumed */
            pgstat_progress_update_param(PROGRESS_VACUUM_INDEXES_PROCESSED,
                                         idx + 1);
 
            if (lazy_check_wraparound_failsafe(vacrel))
            {
                /* Wraparound emergency -- end current index scan */
                allindexes = false;
                break;
            }
        }
    }
    else
    {
        /* Outsource everything to parallel variant */
        parallel_vacuum_bulkdel_all_indexes(vacrel->pvs, old_live_tuples,
                                            vacrel->num_index_scans);
 
        /*
         * Do a postcheck to consider applying wraparound failsafe now.  Note
         * that parallel VACUUM only gets the precheck and this postcheck.
         */
        if (lazy_check_wraparound_failsafe(vacrel))
            allindexes = false;
    }
 
    /*
     * We delete all LP_DEAD items from the first heap pass in all indexes on
     * each call here (except calls where we choose to do the failsafe). This
     * makes the next call to lazy_vacuum_heap_rel() safe (except in the event
     * of the failsafe triggering, which prevents the next call from taking
     * place).
     */
    Assert(vacrel->num_index_scans > 0 ||
           vacrel->dead_items_info->num_items == vacrel->lpdead_items);
    Assert(allindexes || VacuumFailsafeActive);
 
    /*
     * Increase and report the number of index scans.  Also, we reset
     * PROGRESS_VACUUM_INDEXES_TOTAL and PROGRESS_VACUUM_INDEXES_PROCESSED.
     *
     * We deliberately include the case where we started a round of bulk
     * deletes that we weren't able to finish due to the failsafe triggering.
     */
    vacrel->num_index_scans++;
    progress_end_val[0] = 0;
    progress_end_val[1] = 0;
    progress_end_val[2] = vacrel->num_index_scans;
    pgstat_progress_update_multi_param(3, progress_end_index, progress_end_val);
 
    return allindexes;
}

References Assert(), LVRelState::dead_items_info, LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, idx(), LVRelState::indrels, LVRelState::indstats, lazy_check_wraparound_failsafe(), lazy_vacuum_one_index(), LVRelState::lpdead_items, LVRelState::nindexes, LVRelState::num_index_scans, VacDeadItemsInfo::num_items, parallel_vacuum_bulkdel_all_indexes(), ParallelVacuumIsActive, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_VACUUM_INDEXES_PROCESSED, PROGRESS_VACUUM_INDEXES_TOTAL, PROGRESS_VACUUM_NUM_INDEX_VACUUMS, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_INDEX, LVRelState::pvs, RelationData::rd_rel, LVRelState::rel, and VacuumFailsafeActive.

Referenced by lazy_vacuum().

lazy_vacuum_heap_page()

static void lazy_vacuum_heap_page ( LVRelState *  vacrel, BlockNumber  blkno, Buffer  buffer, OffsetNumber *  deadoffsets, int  num_offsets, Buffer  vmbuffer  )

static

Definition at line 2876 of file vacuumlazy.c.

{
    Page        page = BufferGetPage(buffer);
    OffsetNumber unused[MaxHeapTuplesPerPage];
    int         nunused = 0;
    TransactionId visibility_cutoff_xid;
    TransactionId conflict_xid = InvalidTransactionId;
    bool        all_frozen;
    LVSavedErrInfo saved_err_info;
    uint8       vmflags = 0;
 
    Assert(vacrel->do_index_vacuuming);
 
    pgstat_progress_update_param(PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, blkno);
 
    /* Update error traceback information */
    update_vacuum_error_info(vacrel, &saved_err_info,
                             VACUUM_ERRCB_PHASE_VACUUM_HEAP, blkno,
                             InvalidOffsetNumber);
 
    /*
     * Before marking dead items unused, check whether the page will become
     * all-visible once that change is applied. This lets us reap the tuples
     * and mark the page all-visible within the same critical section,
     * enabling both changes to be emitted in a single WAL record. Since the
     * visibility checks may perform I/O and allocate memory, they must be
     * done outside the critical section.
     */
    if (heap_page_would_be_all_visible(vacrel->rel, buffer,
                                       vacrel->cutoffs.OldestXmin,
                                       deadoffsets, num_offsets,
                                       &all_frozen, &visibility_cutoff_xid,
                                       &vacrel->offnum))
    {
        vmflags |= VISIBILITYMAP_ALL_VISIBLE;
        if (all_frozen)
        {
            vmflags |= VISIBILITYMAP_ALL_FROZEN;
            Assert(!TransactionIdIsValid(visibility_cutoff_xid));
        }
 
        /*
         * Take the lock on the vmbuffer before entering a critical section.
         * The heap page lock must also be held while updating the VM to
         * ensure consistency.
         */
        LockBuffer(vmbuffer, BUFFER_LOCK_EXCLUSIVE);
    }
 
    START_CRIT_SECTION();
 
    for (int i = 0; i < num_offsets; i++)
    {
        ItemId      itemid;
        OffsetNumber toff = deadoffsets[i];
 
        itemid = PageGetItemId(page, toff);
 
        Assert(ItemIdIsDead(itemid) && !ItemIdHasStorage(itemid));
        ItemIdSetUnused(itemid);
        unused[nunused++] = toff;
    }
 
    Assert(nunused > 0);
 
    /* Attempt to truncate line pointer array now */
    PageTruncateLinePointerArray(page);
 
    if ((vmflags & VISIBILITYMAP_VALID_BITS) != 0)
    {
        /*
         * The page is guaranteed to have had dead line pointers, so we always
         * set PD_ALL_VISIBLE.
         */
        PageSetAllVisible(page);
        visibilitymap_set_vmbits(blkno,
                                 vmbuffer, vmflags,
                                 vacrel->rel->rd_locator);
        conflict_xid = visibility_cutoff_xid;
    }
 
    /*
     * Mark buffer dirty before we write WAL.
     */
    MarkBufferDirty(buffer);
 
    /* XLOG stuff */
    if (RelationNeedsWAL(vacrel->rel))
    {
        log_heap_prune_and_freeze(vacrel->rel, buffer,
                                  vmflags != 0 ? vmbuffer : InvalidBuffer,
                                  vmflags,
                                  conflict_xid,
                                  false,    /* no cleanup lock required */
                                  PRUNE_VACUUM_CLEANUP,
                                  NULL, 0,  /* frozen */
                                  NULL, 0,  /* redirected */
                                  NULL, 0,  /* dead */
                                  unused, nunused);
    }
 
    END_CRIT_SECTION();
 
    if ((vmflags & VISIBILITYMAP_ALL_VISIBLE) != 0)
    {
        /* Count the newly set VM page for logging */
        LockBuffer(vmbuffer, BUFFER_LOCK_UNLOCK);
        vacrel->vm_new_visible_pages++;
        if (all_frozen)
            vacrel->vm_new_visible_frozen_pages++;
    }
 
    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrel, &saved_err_info);
}

References Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), LVRelState::cutoffs, LVRelState::do_index_vacuuming, END_CRIT_SECTION, heap_page_would_be_all_visible(), i, InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, ItemIdHasStorage, ItemIdIsDead, ItemIdSetUnused, LockBuffer(), log_heap_prune_and_freeze(), MarkBufferDirty(), MaxHeapTuplesPerPage, LVRelState::offnum, VacuumCutoffs::OldestXmin, PageGetItemId(), PageSetAllVisible(), PageTruncateLinePointerArray(), pgstat_progress_update_param(), PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, PRUNE_VACUUM_CLEANUP, RelationData::rd_locator, LVRelState::rel, RelationNeedsWAL, restore_vacuum_error_info(), START_CRIT_SECTION, TransactionIdIsValid, update_vacuum_error_info(), VACUUM_ERRCB_PHASE_VACUUM_HEAP, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_set_vmbits(), VISIBILITYMAP_VALID_BITS, LVRelState::vm_new_visible_frozen_pages, and LVRelState::vm_new_visible_pages.

Referenced by lazy_vacuum_heap_rel().

lazy_vacuum_heap_rel()

static void lazy_vacuum_heap_rel ( LVRelState *  vacrel )

static

Definition at line 2758 of file vacuumlazy.c.

{
    ReadStream *stream;
    BlockNumber vacuumed_pages = 0;
    Buffer      vmbuffer = InvalidBuffer;
    LVSavedErrInfo saved_err_info;
    TidStoreIter *iter;
 
    Assert(vacrel->do_index_vacuuming);
    Assert(vacrel->do_index_cleanup);
    Assert(vacrel->num_index_scans > 0);
 
    /* 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(vacrel, &saved_err_info,
                             VACUUM_ERRCB_PHASE_VACUUM_HEAP,
                             InvalidBlockNumber, InvalidOffsetNumber);
 
    iter = TidStoreBeginIterate(vacrel->dead_items);
 
    /*
     * Set up the read stream for vacuum's second pass through the heap.
     *
     * It is safe to use batchmode, as vacuum_reap_lp_read_stream_next() does
     * not need to wait for IO and does not perform locking. Once we support
     * parallelism it should still be fine, as presumably the holder of locks
     * would never be blocked by IO while holding the lock.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_USE_BATCHING,
                                        vacrel->bstrategy,
                                        vacrel->rel,
                                        MAIN_FORKNUM,
                                        vacuum_reap_lp_read_stream_next,
                                        iter,
                                        sizeof(TidStoreIterResult));
 
    while (true)
    {
        BlockNumber blkno;
        Buffer      buf;
        Page        page;
        TidStoreIterResult *iter_result;
        Size        freespace;
        OffsetNumber offsets[MaxOffsetNumber];
        int         num_offsets;
 
        vacuum_delay_point(false);
 
        buf = read_stream_next_buffer(stream, (void **) &iter_result);
 
        /* The relation is exhausted */
        if (!BufferIsValid(buf))
            break;
 
        vacrel->blkno = blkno = BufferGetBlockNumber(buf);
 
        Assert(iter_result);
        num_offsets = TidStoreGetBlockOffsets(iter_result, offsets, lengthof(offsets));
        Assert(num_offsets <= lengthof(offsets));
 
        /*
         * 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.
         */
        visibilitymap_pin(vacrel->rel, blkno, &vmbuffer);
 
        /* We need a non-cleanup exclusive lock to mark dead_items unused */
        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
        lazy_vacuum_heap_page(vacrel, blkno, buf, offsets,
                              num_offsets, vmbuffer);
 
        /* Now that we've vacuumed the page, record its available space */
        page = BufferGetPage(buf);
        freespace = PageGetHeapFreeSpace(page);
 
        UnlockReleaseBuffer(buf);
        RecordPageWithFreeSpace(vacrel->rel, blkno, freespace);
        vacuumed_pages++;
    }
 
    read_stream_end(stream);
    TidStoreEndIterate(iter);
 
    vacrel->blkno = InvalidBlockNumber;
    if (BufferIsValid(vmbuffer))
        ReleaseBuffer(vmbuffer);
 
    /*
     * We set all LP_DEAD items from the first heap pass to LP_UNUSED during
     * the second heap pass.  No more, no less.
     */
    Assert(vacrel->num_index_scans > 1 ||
           (vacrel->dead_items_info->num_items == vacrel->lpdead_items &&
            vacuumed_pages == vacrel->lpdead_item_pages));
 
    ereport(DEBUG2,
            (errmsg("table \"%s\": removed %" PRId64 " dead item identifiers in %u pages",
                    vacrel->relname, vacrel->dead_items_info->num_items,
                    vacuumed_pages)));
 
    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrel, &saved_err_info);
}

References Assert(), LVRelState::blkno, LVRelState::bstrategy, buf, BUFFER_LOCK_EXCLUSIVE, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), LVRelState::dead_items, LVRelState::dead_items_info, DEBUG2, LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, ereport, errmsg(), InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, lazy_vacuum_heap_page(), lengthof, LockBuffer(), LVRelState::lpdead_item_pages, LVRelState::lpdead_items, MAIN_FORKNUM, MaxOffsetNumber, LVRelState::num_index_scans, VacDeadItemsInfo::num_items, PageGetHeapFreeSpace(), pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_HEAP, read_stream_begin_relation(), read_stream_end(), READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RecordPageWithFreeSpace(), LVRelState::rel, ReleaseBuffer(), LVRelState::relname, restore_vacuum_error_info(), TidStoreBeginIterate(), TidStoreEndIterate(), TidStoreGetBlockOffsets(), UnlockReleaseBuffer(), update_vacuum_error_info(), vacuum_delay_point(), VACUUM_ERRCB_PHASE_VACUUM_HEAP, vacuum_reap_lp_read_stream_next(), and visibilitymap_pin().

Referenced by lazy_vacuum().

lazy_vacuum_one_index()

static IndexBulkDeleteResult * lazy_vacuum_one_index ( Relation  indrel, IndexBulkDeleteResult *  istat, double  reltuples, LVRelState *  vacrel  )

static

Definition at line 3129 of file vacuumlazy.c.

{
    IndexVacuumInfo ivinfo;
    LVSavedErrInfo saved_err_info;
 
    ivinfo.index = indrel;
    ivinfo.heaprel = vacrel->rel;
    ivinfo.analyze_only = false;
    ivinfo.report_progress = false;
    ivinfo.estimated_count = true;
    ivinfo.message_level = DEBUG2;
    ivinfo.num_heap_tuples = reltuples;
    ivinfo.strategy = vacrel->bstrategy;
 
    /*
     * Update error traceback information.
     *
     * The index name is saved during this phase and restored immediately
     * after this phase.  See vacuum_error_callback.
     */
    Assert(vacrel->indname == NULL);
    vacrel->indname = pstrdup(RelationGetRelationName(indrel));
    update_vacuum_error_info(vacrel, &saved_err_info,
                             VACUUM_ERRCB_PHASE_VACUUM_INDEX,
                             InvalidBlockNumber, InvalidOffsetNumber);
 
    /* Do bulk deletion */
    istat = vac_bulkdel_one_index(&ivinfo, istat, vacrel->dead_items,
                                  vacrel->dead_items_info);
 
    /* Revert to the previous phase information for error traceback */
    restore_vacuum_error_info(vacrel, &saved_err_info);
    pfree(vacrel->indname);
    vacrel->indname = NULL;
 
    return istat;
}

References IndexVacuumInfo::analyze_only, Assert(), LVRelState::bstrategy, LVRelState::dead_items, LVRelState::dead_items_info, DEBUG2, IndexVacuumInfo::estimated_count, IndexVacuumInfo::heaprel, IndexVacuumInfo::index, LVRelState::indname, InvalidBlockNumber, InvalidOffsetNumber, IndexVacuumInfo::message_level, IndexVacuumInfo::num_heap_tuples, pfree(), pstrdup(), LVRelState::rel, RelationGetRelationName, IndexVacuumInfo::report_progress, restore_vacuum_error_info(), IndexVacuumInfo::strategy, update_vacuum_error_info(), vac_bulkdel_one_index(), and VACUUM_ERRCB_PHASE_VACUUM_INDEX.

Referenced by lazy_vacuum_all_indexes().

restore_vacuum_error_info()

static void restore_vacuum_error_info ( LVRelState *  vacrel, const LVSavedErrInfo *  saved_vacrel  )

static

Definition at line 3965 of file vacuumlazy.c.

{
    vacrel->blkno = saved_vacrel->blkno;
    vacrel->offnum = saved_vacrel->offnum;
    vacrel->phase = saved_vacrel->phase;
}

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

Referenced by lazy_cleanup_one_index(), lazy_vacuum_heap_page(), lazy_vacuum_heap_rel(), and lazy_vacuum_one_index().

should_attempt_truncation()

static bool should_attempt_truncation ( LVRelState *  vacrel )

static

Definition at line 3238 of file vacuumlazy.c.

{
    BlockNumber possibly_freeable;
 
    if (!vacrel->do_rel_truncate || VacuumFailsafeActive)
        return false;
 
    possibly_freeable = vacrel->rel_pages - vacrel->nonempty_pages;
    if (possibly_freeable > 0 &&
        (possibly_freeable >= REL_TRUNCATE_MINIMUM ||
         possibly_freeable >= vacrel->rel_pages / REL_TRUNCATE_FRACTION))
        return true;
 
    return false;
}

References LVRelState::do_rel_truncate, LVRelState::nonempty_pages, LVRelState::rel_pages, REL_TRUNCATE_FRACTION, REL_TRUNCATE_MINIMUM, and VacuumFailsafeActive.

Referenced by heap_vacuum_rel().

update_relstats_all_indexes()

static void update_relstats_all_indexes ( LVRelState *  vacrel )

static

Definition at line 3847 of file vacuumlazy.c.

{
    Relation   *indrels = vacrel->indrels;
    int         nindexes = vacrel->nindexes;
    IndexBulkDeleteResult **indstats = vacrel->indstats;
 
    Assert(vacrel->do_index_cleanup);
 
    for (int idx = 0; idx < nindexes; idx++)
    {
        Relation    indrel = indrels[idx];
        IndexBulkDeleteResult *istat = indstats[idx];
 
        if (istat == NULL || istat->estimated_count)
            continue;
 
        /* Update index statistics */
        vac_update_relstats(indrel,
                            istat->num_pages,
                            istat->num_index_tuples,
                            0, 0,
                            false,
                            InvalidTransactionId,
                            InvalidMultiXactId,
                            NULL, NULL, false);
    }
}

References Assert(), LVRelState::do_index_cleanup, IndexBulkDeleteResult::estimated_count, idx(), LVRelState::indrels, LVRelState::indstats, InvalidMultiXactId, InvalidTransactionId, LVRelState::nindexes, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, and vac_update_relstats().

Referenced by heap_vacuum_rel().

update_vacuum_error_info()

static void update_vacuum_error_info ( LVRelState *  vacrel, LVSavedErrInfo *  saved_vacrel, int  phase, BlockNumber  blkno, OffsetNumber  offnum  )

static

Definition at line 3946 of file vacuumlazy.c.

{
    if (saved_vacrel)
    {
        saved_vacrel->offnum = vacrel->offnum;
        saved_vacrel->blkno = vacrel->blkno;
        saved_vacrel->phase = vacrel->phase;
    }
 
    vacrel->blkno = blkno;
    vacrel->offnum = offnum;
    vacrel->phase = phase;
}

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

Referenced by lazy_cleanup_one_index(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_heap_page(), lazy_vacuum_heap_rel(), and lazy_vacuum_one_index().

vacuum_error_callback()

static void vacuum_error_callback ( void *  arg )

static

Definition at line 3882 of file vacuumlazy.c.

{
    LVRelState *errinfo = arg;
 
    switch (errinfo->phase)
    {
        case VACUUM_ERRCB_PHASE_SCAN_HEAP:
            if (BlockNumberIsValid(errinfo->blkno))
            {
                if (OffsetNumberIsValid(errinfo->offnum))
                    errcontext("while scanning block %u 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 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 */
    }
}

References arg, LVRelState::blkno, BlockNumberIsValid(), errcontext, LVRelState::indname, LVRelState::offnum, OffsetNumberIsValid, LVRelState::phase, LVRelState::relname, LVRelState::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().

vacuum_reap_lp_read_stream_next()

static BlockNumber vacuum_reap_lp_read_stream_next ( ReadStream *  stream, void *  callback_private_data, void *  per_buffer_data  )

static

Definition at line 2720 of file vacuumlazy.c.

{
    TidStoreIter *iter = callback_private_data;
    TidStoreIterResult *iter_result;
 
    iter_result = TidStoreIterateNext(iter);
    if (iter_result == NULL)
        return InvalidBlockNumber;
 
    /*
     * Save the TidStoreIterResult for later, so we can extract the offsets.
     * It is safe to copy the result, according to TidStoreIterateNext().
     */
    memcpy(per_buffer_data, iter_result, sizeof(*iter_result));
 
    return iter_result->blkno;
}

References TidStoreIterResult::blkno, InvalidBlockNumber, and TidStoreIterateNext().

Referenced by lazy_vacuum_heap_rel().